def interest_entity(request, entity_type='article', entity_external_id=None):
try:
entity = EntityProxy.objects.filter(externalId=entity_external_id,
entity_type=entity_type)
if not entity:
entity = EntityProxy(externalId=entity_external_id,
entity_type=entity_type)
entity.save()
if request.method == 'POST':
# Add interest
request.user.profile.add_interest(entity)
message = 'interest in entity added'
if request.method == 'DELETE':
# Remove interest
request.user.profile.delete_interest(EntityProxy, entity.pk)
message = 'interest in entity removed'
return success('ok', message, {})
except Exception as e:
print(e)
response = JsonResponse({'status': 'error', 'message': e})
response.status_code = 500
return response
def get_profile_projects(request, profile_id):
from dashboard.serializer import ProjectSerializer
try:
profile = Profile.objects.get(pk=profile_id)
projects = Project.objects.filter(profile=profile)
serialized = ProjectSerializer(projects, many=True)
return success('ok', 'user projects', serialized.data)
except Exception as e:
print(e)
response = JsonResponse({'status': 'error', 'message': ''})
response.status_code = 500
return response
def get_entity_details(request, entity='news', entity_id=None):
results = []
profile = None
try:
method_to_call = 'get_' + entity+'_detail'
results = getattr(DSPConnectorV13, method_to_call)(entity_id=entity_id)[entity]
except DSPConnectorException:
pass
except AttributeError as a:
if entity == 'projects':
local_entities = Project.objects.get(pk=entity_id)
results = ProjectSerializer(local_entities).data
else:
local_entities = Challenge.objects.get(pk=entity_id)
results = ChallengeSerializer(local_entities, many=True).data
return success('ok', 'single entity', results)
def interest_project(request, project_id):
try:
project = Project.objects.get(pk=project_id)
if request.method == 'POST':
# Add interest
request.user.profile.add_interest(project)
message = 'interest in project added'
if request.method == 'DELETE':
# Remove interest
request.user.profile.delete_interest(Project, project_id)
message = 'interest in project removed'
return success('ok', message, {})
except Exception as e:
print(e)
response = JsonResponse({'status': 'error', 'message': e})
response.status_code = 500
return response
def get_entity_details(request, entity='news', entity_id=None):
results = []
profile = None
try:
method_to_call = 'get_' + entity + '_detail'
results = getattr(DSPConnectorV13,
method_to_call)(entity_id=entity_id)[entity]
except DSPConnectorException as e:
print('ERROR[dashboard.api14.bookmark]: DSPConnectorException')
print(e)
except AttributeError as a:
print('NOT FOUND[dashboard.api14.bookmark]: DSPConnectorException')
if entity == 'projects':
local_entities = Project.objects.get(pk=entity_id)
results = ProjectSerializer(local_entities).data
else:
local_entities = Challenge.objects.get(pk=entity_id)
results = ChallengeSerializer(local_entities, many=True).data
return success('ok', 'single entity', results)
def get_entity(request, entity='news'):
#TODO make cursor works
profile = None
results = []
local_entities = None
try:
profile = request.user.profile
except:
# NOt logged user
profile = None
try:
topics_list = DSPConnectorV12.get_topics()['topics']
topics_id_list = [x['topic_id'] for x in topics_list]
method_to_call = 'get_' + entity
if not profile:
selected_topic = random.choice(topics_id_list)
results = getattr(
DSPConnectorV13,
method_to_call)(topic_id=selected_topic)[entity]
results = results[:5]
else:
for index, topic_id in enumerate(topics_id_list):
results.append(
getattr(DSPConnectorV13,
method_to_call)(topic_id=topic_id)[entity])
results = mix_result_round_robin(*results)
except DSPConnectorException:
pass
except AttributeError as a:
local_entities = Project.objects.all()
if not profile:
local_entities = local_entities[:5]
results.extend(ProjectSerializer(local_entities, many=True).data)
local_entities = Challenge.objects.all()
if not profile:
local_entities = local_entities[:5]
results.extend(ChallengeSerializer(local_entities, many=True).data)
return success('ok', 'entity list', results)
def bookmark(request, entity='news', entity_id=None):
# GET return status of a bookmark (ES: {bookmarked:true|false})
# POST toggle status of a bookmark an return it (ES: {bookmarked:true|false})
results = {}
try:
local_entity = None
profile = request.user.profile
try:
local_entity = ModelHelper.find_this_entity(entity, entity_id)
except ObjectDoesNotExist as odne:
return not_found()
if request.method == 'POST':
results['bookmarked'] = profile.bookmark_this(local_entity)
else:
results['bookmarked'] = profile.is_this_bookmarked_by_me(
local_entity)
return success('ok', 'bookmark', results)
except AttributeError as a:
return not_authorized()
except Exception as e:
print(e)
return not_authorized()
def project(request, project_id=None):
from dashboard.serializer import ProjectSerializer
# DELETE PROJECT
if request.method == 'DELETE' and project_id is not None:
try:
profile = request.user.profile
projects = Project.objects.get(id=project_id, profile=profile)
projects.delete()
except ObjectDoesNotExist as e:
print(e)
print(not_authorized())
return success('ok', 'project deleted', {})
# GET ALL
if request.method == 'GET' and project_id is None:
try:
profile = request.user.profile
projects = Project.objects.filter(profile=profile)
serialized = ProjectSerializer(projects, many=True)
return success('ok', 'user projects', serialized.data)
except Exception as e:
print(e)
return not_found()
# GET SINGLE
if request.method == 'GET' and project_id is not None:
try:
project = Project.objects.filter(id=project_id)
serialized = ProjectSerializer(project, many=True)
return success('ok', 'single project', serialized.data)
except ObjectDoesNotExist as o:
print(o)
return not_found()
except Exception as e:
print(e)
return error()
# UPDATE
if request.method == 'POST' and project_id is not None:
data_to_update = {}
data_to_update['name'] = request.POST.get('name', '')
data_to_update['description'] = request.POST.get('description', '')
data_to_update['start_date'] = request.POST.get('start_date', '')
data_to_update['creator_role'] = request.POST.get(
'creator_role', '')
data_to_update['project_url'] = request.POST.get('project_url', '')
end_date = request.POST.get('end_date', '')
# check if the image needs to be updated
if request.POST.get('picture', None) != '':
# image to be updated
picture = request.FILES.get('picture')
v13.check_image(picture)
data_to_update['picture'] = picture
# check if is or not an ongoing project
try:
if end_date != '':
end_date = dt.strptime(end_date, '%Y-%m-%d')
data_to_update['start_date'] = dt.strptime(
data_to_update['start_date'], '%Y-%m-%d')
# if end_date > dt.now():
# return bad_request('The project end_date cannot be in the future')
if end_date < data_to_update['start_date']:
return bad_request(
'The project end date cannot be before the project start date'
)
data_to_update['end_date'] = end_date
except Exception as e:
print(e)
return error()
# get the model object and check the profile owns that project
try:
profile = request.user.profile
project = Project.objects.filter(id=project_id,
profile=profile).first()
# clear and update tag
project.set_tags(request.POST.get('tags', ''))
# remove tag from data_to_update
project.__dict__.update(data_to_update)
project.save()
except Project.DoesNotExist as e:
print(e)
return not_authorized()
except Exception as e:
print(e)
return error()
result = ProjectSerializer(project).data
return success('ok', 'project updated', result)
# CREATE
if request.method == 'POST' and project_id is None:
# check if fields are filled
try:
project_image = request.FILES.get('picture')
project_name = request.POST['name']
project_description = request.POST['description']
project_start_date = dt.strptime(request.POST['start_date'],
'%Y-%m-%d')
project_creator_role = request.POST['creator_role']
project_url = request.POST['project_url']
project_tags = request.POST['tags']
# Check image
is_image_ok = v13.check_image(project_image)
if is_image_ok is not True:
return is_image_ok
except KeyError as k:
print(k)
return bad_request("Please fill all the fields")
except Exception as e:
return bad_request(e)
# check if is or not an ongoing project
try:
project_end_date = dt.strptime(request.POST['end_date'],
'%Y-%m-%d')
except KeyError:
project_end_date = None
# if it is not an ongoing project check dates
if project_end_date is not None:
if project_end_date < project_start_date:
return bad_request(
'The project END DATE cannot be before the project START DATE'
)
try:
# check user has not project with that name
profile = request.user.profile
projects = Project.objects.filter(profile=profile,
name=project_name)
if len(projects) > 0:
return bad_request('Project name already exist')
project = Project(profile=profile,
name=project_name,
picture=project_image,
description=project_description,
start_date=project_start_date,
end_date=project_end_date,
creator_role=project_creator_role,
project_url=project_url)
project.save()
project.tags.clear()
for tagName in [
x.lower().capitalize() for x in project_tags.split(",")
]:
project.tags.add(
Tag.objects.filter(name=tagName).first()
or Tag.create(name=tagName))
project.save()
result = ProjectSerializer(project).data
except Exception as e:
return bad_request(e)
return success('ok', 'project created', result)
def project_invitation(request, status=None):
# ToDo add token to avoid actions not allowed
from dashboard.serializer import ProjectContributorSerializer
if request.method == 'POST':
try:
body = json.loads(request.body)
project_id = body['project_id']
profile_id = body['profile_id']
profile = Profile.objects.get(id=profile_id)
project = Project.objects.get(id=project_id,
profile=request.user.profile)
# can not invite yourself
if profile == request.user.profile:
return bad_request('you are the owner of the project')
contribution = ProjectContributor.objects.filter(
project=project, contributor=profile)
if len(contribution):
if status is not None:
# update the status of the invitation / collaboration
contribution.update(status=status)
serialized = ProjectContributorSerializer(
contribution).data
return success('ok', 'invitation updated', serialized)
else:
# ToDo send e-mail
email_context = {
'FIRST_NAME':
profile.user.first_name,
'LAST_NAME':
profile.user.last_name,
'PROJECT_OWNER_FIRST_NAME':
request.user.first_name,
'PROJECT_OWNER_LAST_NAME':
request.user.last_name,
'PROJECT_NAME':
project.name,
'CONFIRMATION_LINK':
'http://{}/profile/{}/invitation/{}/accepted/'.
format(
get_current_site(request),
profile.id,
project.id,
),
'DECLINE_LINK':
'http://{}/profile/{}/invitation/{}/declined/'.
format(
get_current_site(request),
profile.id,
project.id,
),
}
if contribution.first().status == 'pending':
message = 'invitation re-sent'
else:
contribution.update(status='pending')
message = 'invitation sent'
EmailHelper.email(
template_name='collaborator_invitation',
title='Openmaker Explorer - Project nomination',
vars=email_context,
receiver_email=profile.user.email)
serialized = ProjectContributorSerializer(
contribution).data
return success('ok', message, serialized)
else:
'CREATING NEW INVITATION'
# invitation not exist --> create and send e-mail
contribution = ProjectContributor(project=project,
contributor=profile)
contribution.save()
email_context = {
'FIRST_NAME':
profile.user.first_name,
'LAST_NAME':
profile.user.last_name,
'PROJECT_OWNER_FIRST_NAME':
request.user.first_name,
'PROJECT_OWNER_LAST_NAME':
request.user.last_name,
'PROJECT_NAME':
project.name,
'CONFIRMATION_LINK':
'http://{}/profile/{}/invitation/{}/accepted/'.format(
get_current_site(request),
profile.id,
project.id,
),
'DECLINE_LINK':
'http://{}/profile/{}/invitation/{}/declined/'.format(
get_current_site(request),
profile.id,
project.id,
),
}
EmailHelper.email(
template_name='collaborator_invitation',
title='Openmaker Explorer - Project nomination',
vars=email_context,
receiver_email=profile.user.email)
serialized = ProjectContributorSerializer(
contribution).data
return success('ok', 'invitation sent', serialized)
except ObjectDoesNotExist as o:
print('ERROR ObjectDoesNotExist')
print(o)
return error()
except Exception as e:
print('ERROR Exception')
print(e)
return error()
else:
bad_request('only post for now')
