def delete(self, key):
if auth.user_is_admin():
Project.get(key).delete()
else:
Messages.add('Only and administrator may delete projects. This ' +
'incident has been logged.')
return self.redirect('/projects')
def delete(self, key):
"""Deletes a project."""
if auth.user_is_admin():
Project.get(key).delete()
else:
Messages.add('Only and administrator may delete projects. This ' +
'incident has been logged.')
return self.redirect('/projects')
def test_create_outgoing(self):
"""Create an outgoing record."""
Category.create(category_id='001', description='Testing Stock')
Project.create(project_id='001', project_description="Testing")
Role.create(role_name='Admin')
User.create(first_name='Jay', second_name='Palm', phone='9783978223', role='Admin', username='******',
password='******', email='*****@*****.**')
create_stock('001', 'Testing stock', 1, '001', 9.99)
create_outgoing_stock(stock='001', project_id='001', date="2015-07-22", quantity='7', username='******')
OutgoingStock.get(OutgoingStock.stock == '001').delete_instance()
Stock.get(Stock.category == '001').delete_instance()
User.get(User.username == 'JayPalm').delete_instance()
Role.get(Role.role_name == 'Admin').delete_instance()
Project.get(Project.project_id == '001').delete_instance()
Category.get(Category.category_id == '001').delete_instance()
def button(bot, update):
'''Save user vote in the database'''
query = update.callback_query
username = query.message['chat']['username']
chat_id = query.message.chat_id
user = Pycampista.get_or_create(username=username, chat_id=chat_id)[0]
project_name = query.message['text']
# Get project from the database
project = Project.get(Project.name == project_name)
# create a new vote object
new_vote = Vote(pycampista=user, project=project)
# Save vote in the database and send a message
if query.data == "si":
result = 'Interesadx en: ' + project_name + ' 👍'
new_vote.interest = True
new_vote.save()
else:
new_vote.interest = False
new_vote.save()
result = 'No te interesa el proyecto ' + project_name
bot.edit_message_text(text=result,
chat_id=query.message.chat_id,
message_id=query.message.message_id)
def post(self):
waiver = self.request.get('waiver')
if waiver != 'yes':
raise ValidationError(
errors={'waiver': 'You must accept the waiver'})
name = self.request.get('name')
email = self.request.get('email')
user = User.findByEmail(email)
if user != None:
code = 9202 if user.pending == True else 4482
return self.redirect('/sign-in', {'error': code, 'email': email})
password = self.request.get('password')
if len(password) < 5:
raise ValidationError(
errors={'password': '******'})
pid = self.request.get('pid')
project = Project.get(pid) if pid else None
gid = self.request.get('group[key]')
group = Group.get(gid) if gid else None
group_code = self.request.get('group[password]')
group = group if group and group.password == group_code else None
user = User.create(name, email, password, project, group)
self.setUser(user)
redirect = self.request.get('redirect')
redirect = redirect if redirect else '/account'
self.redirect(redirect)
def post(self, key):
group = self.getGroup(key)
if group is None:
group = Group()
group.name = self.request.get('group[name]')
group.password = self.request.get('group[password]')
try:
slots = int(self.request.get('group[slots]'))
if slots <= 0:
raise ValueError('Below zero')
group.slots = slots
except ValueError as e:
raise ValidationError(
errors={
'group[slots]': 'Must be an integer number above zero'
})
project_key = self.request.get('group[project]')
project = Project.get(project_key) if project_key != '' else None
group.setProject(project)
group.put()
error_code = 1 if key == 'new' else 2
self.redirect('/admin/groups/{}'.format(group.key()),
{'error': error_code})
def post(self):
action = self.request.get('action', 'add')
if action == 'add':
if len(self.request.get('name'))<2:
raise Exception("project name must be at least 2 characters long")
if len(self.request.get('currency'))<1:
raise Exception("project currency must be at least one character long")
# create the project and return the new location to go to
project = Project(name=self.request.get('name'), currency=self.request.get('currency'))
project.put()
# add access rights for this user to the new project
rights = ProjectRights(project=project, user=users.GetCurrentUser(), right=Security.Right_Owner)
rights.put()
# redirect to summary
self.response.out.write("/summary?project=%(key)s" % {'key':project.key()})
elif action == 'delete':
# remove me from the projects right list
project = Project.get(self.request.get('project', ''))
if (not project):
raise Exception("Unknown project!")
# check rights of current user for this project, and deny access if not permitable
rights = ProjectRights.gql("WHERE user=:user and project=:project", user=users.get_current_user(), project=project).get()
if rights:
rights.delete()
# redirect to my page
self.response.out.write("/")
else:
raise Exception("Unknown action '%(action)s'!" % {'action':action})
def update_project(project_id):
new_project = request.get_json()
try:
project = Project.get(Project.id == project_id)
except models.DoesNotExist:
return jsonify({ 'message': 'Project not found' }), 400
if new_project['id'] != project.id:
return jsonify({ 'message': 'Cannot update project at this url' }), 400
try:
if new_project['markerOptions']:
marker_options = new_project['markerOptions']
for marker_name in marker_options:
try:
marker_option = MarkerOption.get(MarkerOption.name == marker_name)
ProjectMarkerOption.get(ProjectMarkerOption.project == project.id,
ProjectMarkerOption.marker_option == marker_option.id)
except models.DoesNotExist:
ProjectMarkerOption.create(project = project, marker_option = marker_option)
if new_project['users']:
users = new_project['users']
for user in users:
try:
project_user = ProjectUser.get(ProjectUser.app_user == user['id'],
ProjectUser.project == project)
except models.DoesNotExist:
ProjectUser.create(app_user = user['id'], project = project)
if new_project['stacks']:
stacks = new_project['stacks']
with db.atomic():
for stack in stacks:
try:
project_stack = ProjectStack.get(ProjectStack.stack == stack['id'],
ProjectStack.project == project)
except models.DoesNotExist:
project_stack = ProjectStack.create(project=project, stack = stack['id'])
probe_setting = stack['probeSettings']
probe_position = json.loads(probe_setting['position'])
ProbeSetting.create(x_offset=int(probe_position['xOffset']),
y_offset=int(probe_position['yOffset']),
project_stack=project_stack,
label=probe_position['label']
)
message = "Project updated"
except Exception as ex:
print ex
project = Project.get(Project.id == project_id)
return jsonify({ 'message': 'Project updated', 'project': project.deep_serialized() }), 200
def post(self):
project_id = self.request.get('project-id')
api_token = self.request.get('api-token')
project = Project.get()
project.project_id = project_id
project.api_token = api_token
project.put()
self.redirect('/project')
def delete_project(project_id):
project = Project.get(Project.id == project_id)
if project:
project_title = project.title
project.delete_instance(recursive=True)
return jsonify({ 'message': 'Successfully deleted "{}"'.format(project_title) }), 200
else:
return jsonify({ 'message': 'Unable to delete project' }), 400
def create_project():
user = json.loads(request.data)
user = Project(user["name"], user["description"], user["address"],
int(user["num_people"]), user.get("image", None),
user["date"])
db.session.add(user)
db.session.commit()
return json.dumps({"result": True})
def task(op, project_id, push_id):
f = globals()['task_%s' % op]
project = Project.get(name=project_id)
if not project:
# XXX: cry to log
return
s = partial(push_status, push_id, project)
s._id = push_id
f(project, s)
def save(name):
project = Project.get(name=name)
if not project:
return 'No', 404
project.update(request.form)
project.save()
flash('Saved')
return redirect('/projects/%s/'%name)
def delete_project(project_id):
if authenticate():
try:
project = Project.get(Project.id == project_id)
return render_template('projects/delete.html', project=project)
except Project.DoesNotExist:
return redirect(url_for('projects'))
else:
flash('Not authorized to do that')
return redirect(url_for('projects'))
def vote(self, key):
if not auth.logged_in():
return self.redirect('/projects')
project = Project.get(key)
if project.has_voted(auth.current_user()):
project.remove_vote(auth.current_user())
project.put()
else:
project.vote(auth.current_user())
project.put()
return self.redirect('/projects')
def get(self):
email = self.request.get('email')
pid = self.request.get('pid')
project = Project.get(pid) if pid else None
redirect = self.request.get('redirect')
return {
'email': email,
'project': project,
'Greek': Greek,
'redirect': redirect,
}
def show(name):
project = Project.get(name=name)
if not project:
return "No", 404
(project._field('status')).locked = True
(project._field('rev')).locked = True
status = rstatus_name(name)
return render_template('project_show.html',
project=project, status=status)
def claim(self, key):
user = auth.User(auth.current_user())
group = user.group
if group.owner.user_id() == auth.current_user().user_id():
project = Project.get(key)
group.project = project
group.put()
return self.redirect('/groups/%s' % group.key())
else:
Messages.add('You are not the owner of your group. Only the ' +
'owner of the group may select a project.')
return self.redirect('/projects')
def get_projects_by_company(company_id):
"""
Fetches projects by a company.
:param company_id: A company id from database.
:type company_id: Integer
"""
projects = Project.get('all', Project.company_id == company_id)
lower_case_sorter = lambda project: unicode(project).lower()
projects.sort(key=lower_case_sorter)
return projects
def get_project(project_id: int):
try:
db.connect()
project: Project = Project.get(Project.id == int(project_id))
except Exception as e:
print(e)
message = {"status": False, "error": str(e), "data": {}}
else:
message = {"status": True, "error": {}, "data": project.dict()}
finally:
db.close()
return message
def claim(self, key):
"""Claims a project for a group."""
user = auth.User(auth.current_user())
group = user.group
if group.owner.user_id() == auth.current_user().user_id():
project = Project.get(key)
group.project = project
group.put()
return self.redirect('/groups/%s' % group.key())
else:
Messages.add('You are not the owner of your group. Only the ' +
'owner of the group may select a project.')
return self.redirect('/projects')
def copy_key(name, push_id=None):
project = Project.get(name=name)
project.ssh_key = ops.fetch_key(name)
project.save()
if not push_id:
return
push(push_id, {
"typ": "project.key",
"key": project.ssh_key,
"project": project.name,
})
def vote(self, key):
"""Votes for a project.
This action removes the user's vote from the project if the user had
already voted for it.
"""
if not auth.logged_in():
return self.redirect('/projects')
project = Project.get(key)
if project.has_voted(auth.current_user()):
project.remove_vote(auth.current_user())
project.put()
else:
project.vote(auth.current_user())
project.put()
return self.redirect('/projects')
def add_project(data):
"""
Adds a project to database and returns a project instance
:param data: Project information
:type data: A dictionary
:rtype: an instance of :class:`models.Project`
"""
if 'project' not in data:
return None
if 'company' not in data:
return None
project_data = data['project']
company_data = data['company']
if ('name' not in project_data) or ('name' not in company_data):
return None
project_name = project_data['name']
exists = Project.get('exists', Project.name == project_name)
if exists:
raise ItemAlreadyExistsException('The project exists already!')
company = Company.get('one', Company.name == company_data['name'])
# Parse data.
name = project_data['name']
directory = ''
directory_set = False
if 'dir' in project_data:
directory = project_data['dir']
directory_set = True
password = ''
if 'password' in project_data:
password = project_data['password']
if password:
password = utils.hash_password(password)
directory = utils.get_encrypted_directory_name(name, password)
directory_set = True
project = Project(name, '', company, password)
if directory_set:
project.dir = filesystem.create_project_directory(directory)
else:
project.dir = filesystem.create_project_directory(str(project.id))
if not project.dir:
project.delete()
return None
Project.update(project)
return project
def owneo(bot, update):
'''Dialog to set project responsable'''
username = update.message.from_user.username
text = update.message.text
chat_id = update.message.chat_id
lista_proyectos = [p.name for p in Project.select()]
dic_proyectos = dict(enumerate(lista_proyectos))
# proyecto_usado = dic_proyectos.values(text|)
project_name = dic_proyectos[int(text)]
new_project = Project.get(Project.name == project_name)
user = Pycampista.get_or_create(username=username, chat_id=chat_id)[0]
project_owner = ProjectOwner.get_or_create(project=new_project, owner=user)
bot.send_message(chat_id=update.message.chat_id, text="Perfecto. Chauchi")
def project_update(project_id):
try:
project = Project.get(id=project_id, user=current_user.id)
except Project.DoesNotExist:
return jsonify({
"message":
"Can't find project with id - `{id}`".format(id=project_id),
"status":
"error"
}), 404
project, errors = project_schema.load(request.json, instance=project)
if errors:
return jsonify(errors), 400
project.save()
return jsonify(project_schema.dump(project).data), 201
def _create_new_story(self, event):
logging.info('Creating story')
story = Story(story_id=event.story_id, name=event.story_title)
story.put()
project = Project.get()
api_url = 'http://www.pivotaltracker.com/services/v3/projects/{PROJECT_ID}/stories/{STORY_ID}/notes'.replace('{PROJECT_ID}', project.project_id).replace('{STORY_ID}', story.story_id)
comment_xml = '<note><text>http://{APP_ID}.appspot.com/s/{STORY_ID}</text></note>'.replace('{APP_ID}', os.environ['APPLICATION_ID']).replace('{STORY_ID}', story.story_id)
logging.info('Api url: ' + api_url)
logging.info('Comment xml: ' + comment_xml)
#post a comment back to pivotal tracker
result = urlfetch.fetch(url=api_url,
payload=comment_xml,
method=urlfetch.POST,
headers={'Content-Type': 'application/xml', 'X-TrackerToken': project.api_token})
logging.info('Result of API call: ' + result.content)
def generate_report_xlsx(self, project_id, report_type):
project = Project.get(Project.id == project_id)
total_probes = len([p for p in project.project_stacks])
project_users = AppUser.select().join(ProjectUser).where(ProjectUser.project == project)
project_info = project.title.split('_')
report = {}
total_iteration = 0
for iteration, project_stack in enumerate(project.project_stacks):
stack = {}
stack_images = StackImage.select().where(StackImage.stack == project_stack.stack.id)
for stack_image in stack_images:
users = {}
for user in project_users:
markers = Marker.select().where(
Marker.app_user == user.id,
Marker.stack_image == stack_image.id,
Marker.project_stack == project_stack.id
)
user_markers = [m.serialized for m in markers]
if user_markers:
users[user.email] = user_markers
stack[stack_image.image.name] = users
report[project_stack.stack.title] = stack
self.update_state(state='PROGRESS', meta={
'current': iteration,
'total': total_probes,
'projectId': project_id,
'reportType': report_type
})
total_iteration += 1
return {
'current': total_iteration,
'total': total_probes,
'status': 'Task complete',
'projectId': project_id,
'report': report,
'reportType': report_type
}
def get(self):
self._current_user = self.require_login()
if not self._current_user:
self.authenticate()
return
match = getCurrentMatchByUser(self._current_user.id)
if not match:
self.redirect("/loadout")
return
#Resolve hacker ids to actual hacker data
hacker_list = {}
for hacker in match.hacker_list:
hacker_instance = Hacker.get(hacker)
hacker_list[str(hacker_instance.key())] = {"first_name": hacker_instance.first_name,
"last_name": hacker_instance.last_name,
"talents": hacker_instance.talents,
"imgset": hacker_instance.imageset,
"base": {"energy": hacker_instance.base_energy,
"productivity": hacker_instance.base_productivity,
"teamwork": hacker_instance.base_teamwork}}
#Resolve hackers for this user
self._current_user.hackers = Hacker.all().filter("user ="******"user": self._current_user,
"users": users,
"hackathon": match,
"hackers": json.dumps(hacker_list),
"project": project,
"token": token}))
def post(self, key):
user = self.getVolunteer(key)
user.pending = self.request.get('volunteer[pending]') == "true"
user.pending_code = self.request.get('volunteer[pending_code]')
user.email = self.request.get('volunteer[email]')
user.first_name = self.request.get('volunteer[first_name]')
user.last_name = self.request.get('volunteer[last_name]')
user.is_pc = self.request.get('volunteer[is_pc]') == "true"
user.is_group_leader = self.request.get(
'volunteer[is_group_leader]') == "true"
user.phone = self.request.get('volunteer[phone]')
group_key = self.request.get('volunteer[group]')
group = Group.get(group_key) if group_key != "" else None
user.setGroup(group)
project_key = self.request.get('volunteer[project]')
project = Project.get(project_key) if project_key != "" else None
user.setProject(project)
user.save()
self.redirect('/admin/volunteers/{}'.format(user.key()), {'error': 1})
def index():
curr_project = Project.get(Project.title == "Sinatra Store")
return render_template('index.html', project=curr_project)
def new_project(project):
np = Project.get(id=project)
return np
def test_get(self):
params = {'id': 1}
res = Project.get(**params)
assert res.q == ("SELECT * FROM projects " "WHERE id=%(id)s LIMIT 1;")
assert res.params == params
def single_project(project_id):
if request.method == "POST" and request.form and request.form['_method']:
if authenticate():
if request.form['_method'] == "PUT" or request.form['_method'] == "PATCH":
post = request.form
error = False
title = request.form['title'].strip() if request.form['title'] != None else None
if title:
if re.search("^[ a-zA-Z0-9\,\?\!]+$", title) == None:
flash('Invalid characters detected in title')
error = True
else:
flash('Title cannot be empty')
error = True
title_desc = request.form['title_desc'].strip()
if title_desc:
title_desc = title_desc.replace("\r","")
num_matches = len(re.findall("^[ a-zA-Z0-9\.\?\,\!/]+$",title_desc,re.MULTILINE))
num_lines = len(list(filter(remove_blanks,title_desc.split("\n"))))
if num_matches != num_lines:
flash('Invalid characters detected in title description')
error = True
else:
flash('Title description cannot be blank')
error = True
description = request.form['description'].strip()
if description:
regex = re.compile("^[ a-zA-Z0-9\.\?\,\!]+$", re.MULTILINE)
description = description.replace("\r","")
num_matches = len(regex.findall(description))
num_lines = len(list(filter(remove_blanks,description.split("\n"))))
if num_matches != num_lines:
flash('Invalid characters detected in project description')
error = True
if not error:
try:
q = Project.update(
title=request.form['title'],
title_desc=request.form['title_desc'],
description=request.form['description']
).where(Project.id == project_id)
q.execute()
except IntegrityError:
flash('That title is already taken')
error = True
except Project.DoesNotExist:
return redirect(url_for('projects'))
else:
flash('Project description cannot be empty')
error = True
if error:
return render_template('projects/edit.html', project=project)
else:
return redirect(url_for('single_project', project_id=project_id))
elif request.form['_method'] == "DELETE":
try:
project = Project.get(Project.id == project_id)
project.delete_instance()
flash('Successfully deleted the project')
return redirect(url_for('projects'))
except Project.DoesNotExist:
return redirect(url_for('projects'))
else:
abort(405)
else:
flash('Not authorized to do that')
return redirect(url_for('projects'))
else:
try:
project = Project.get(Project.id == project_id)
tags = ""
learned_points = ""
if project.tags:
tags = project.tags.split(',')
if project.learned:
learned_points = project.learned.replace('+',',')
learned_points = learned_points.split(",")
return render_template('projects/show.html', project=project, tags=tags, learned_points=learned_points)
except Project.DoesNotExist:
return redirect(url_for('projects'))
def create_project():
user = json.loads(request.data)
user = Project(user["name"], user["description"], user["address"], int(user["num_people"]), user.get("image",None), user["date"])
db.session.add(user)
db.session.commit()
return json.dumps({"result":True})
def getProject(self, key):
if key == "new":
return None
project = Project.get(key)
self.throw404If(project is None)
return project
def get(self):
project = Project.get()
appengineutils.render_template(self.response, 'project.html', {'project' : project})
def getProject(self, key):
project = Project.get(key)
self.throw404If(project is None)
return project
def get_project_from_local_conf():
local_conf = yaml_util.load_local_conf()
project_id = local_conf["project_id"]
project = Project.get(Project.id == project_id)
return project
def load_project(project_id):
project = Project.get(Project.id == project_id)
return jsonify({ 'project': project.deep_serialized() }), 200
