def post(self, request):
"""
"""
user = request.user
data = request.DATA
if data.get('name') == 'Default':
return Response("The 'Default' project name is reserved",
status=status.HTTP_409_CONFLICT)
#Default to creating for the 'user-group'
if not data.get('owner'):
data['owner'] = user.username
elif not Group.check_access(user, data['owner']):
return failure_response(
status.HTTP_403_FORBIDDEN,
"Current User: %s - Cannot assign project for group %s"
% (user.username, data['owner']))
serializer = ProjectSerializer(data=data,
context={"user":request.user})
if serializer.is_valid():
serializer.save()
response = Response(
serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, project_id):
"""
"""
user = request.user
data = request.DATA
group = get_user_group(user.username)
project = group.projects.filter(id=project_id)
if not project:
return Response("Project with ID=%s does not exist" % project_id,
status=status.HTTP_400_BAD_REQUEST)
project = project[0]
serializer = ProjectSerializer(project, data=data,
context={"user":request.user})
if serializer.is_valid():
#If the default project was renamed
if project.name == "Default" \
and serializer.object.name != "Default":
#Create another one.
group.projects.get_or_create(name="Default")
serializer.save()
response = Response(
serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def createProject(request):
# product = Product.objects.get(id=pk)
serializer = ProjectSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
def post(self, request):
"""
"""
user = request.user
data = request.DATA
if data.get('name') == 'Default':
return Response("The 'Default' project name is reserved",
status=status.HTTP_409_CONFLICT)
#Default to creating for the 'user-group'
if not data.get('owner'):
data['owner'] = user.username
elif not Group.check_access(user, data['owner']):
return failure_response(
status.HTTP_403_FORBIDDEN,
"Current User: %s - Cannot assign project for group %s" %
(user.username, data['owner']))
serializer = ProjectSerializer(data=data,
context={"user": request.user})
if serializer.is_valid():
serializer.save()
response = Response(serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, project_id):
"""
"""
user = request.user
data = request.DATA
group = get_user_group(user.username)
project = group.projects.filter(id=project_id)
if not project:
return Response("Project with ID=%s does not exist" % project_id,
status=status.HTTP_400_BAD_REQUEST)
project = project[0]
serializer = ProjectSerializer(project,
data=data,
context={"user": request.user})
if serializer.is_valid():
#If the default project was renamed
if project.name == "Default" \
and serializer.object.name != "Default":
#Create another one.
group.projects.get_or_create(name="Default")
serializer.save()
response = Response(serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
project = self.get_object(pk)
serializer = ProjectSerializer(instance=project, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def updateProject(request,pk):
project = Project_model.objects.get(id=pk)
serializer = ProjectSerializer(instance=project,data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
def put(self, request, pk, format=None):
try:
project = get_object(Project, pk)
serializer = ProjectSerializer(project, data=request.data, partial=True)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response(serializer.data)
except ResourceNotFoundException as exc:
return Response(data=exc.data, status=exc.status_code)
def create_project(self, data):
from api.serializers import ProjectSerializer, ProfileItemSerializer
data['creator'] = ProfileItemSerializer(self).data
serializer = ProjectSerializer(data=data)
if serializer.is_valid():
serializer.save()
project = serializer.instance
if not project.is_self:
from api.bot import BotNotification
BotNotification.create_project(project)
return project
print(serializer.errors)
return {'error': 'Ошибка сохранения проекта'}
def pre_save_experiments(sender, instance, using, **kwargs):
print('creating cronjob chart')
job_id = uuid.uuid1().hex[0:5]
release_name = '{}-{}-{}'.format(instance.project.slug, 'cronjob', job_id)
is_cron = 1
if instance.schedule == "None" or instance.schedule == "":
is_cron = 0
from api.serializers import ProjectSerializer
settings_file = ProjectSerializer(instance.project)
settings_file = JSONRenderer().render(settings_file.data)
settings_file = settings_file.decode('utf-8')
settings_file = json.loads(settings_file)
settings_file = yaml.dump(settings_file)
user_config_file = create_user_settings(instance.username)
user_config_file = yaml.dump(json.loads(user_config_file))
parameters = {
"release": release_name,
"chart": "cronjob",
"namespace": settings.NAMESPACE,
"project.slug": instance.project.slug,
"image": instance.environment.image,
"command": '["/bin/bash", "-c", "'+instance.command+'"]',
"iscron": str(is_cron),
"cronjob.schedule": instance.schedule,
"cronjob.port": "8786",
"resources.limits.cpu": "500m",
"resources.limits.memory": "1Gi",
"resources.requests.cpu": "100m",
"resources.requests.memory": "256Mi",
"resources.gpu.enabled": "false",
"settings_file": settings_file,
"user_settings_file": user_config_file,
}
if hasattr(instance, 'options'):
del instance.options['command']
del instance.options['environment']
del instance.options['schedule']
parameters.update(instance.options)
helmchart = HelmResource(name=release_name,
namespace='Default',
chart='cronjob',
params=parameters,
username=instance.username)
helmchart.save()
instance.helmchart = helmchart
def get(self, request, pk, format=None):
try:
project = get_object(Project, pk)
serializer = ProjectSerializer(project)
return Response(serializer.data)
except ResourceNotFoundException as exc:
return Response(data=exc.data, status=exc.status_code)
def getUserProject(request):
stringBody = request.body.decode('utf-8')
jsonBody = json.loads(stringBody)
user = User.objects.get(username=jsonBody['userEmail'])
projects = Project.objects.filter(ownerId=user.id)
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
def get(self, request, pk, format=None):
try:
user = get_object(User, pk)
projects = user.projects.order_by('-created_date')
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
except ResourceNotFoundException as exc:
return Response(data=exc.data, status=exc.status_code)
def get_project_view(request):
projectid = request.query_params.get('id')
if projectid is None:
return Response({"error": "You need to specify \"id\" parameter."})
try:
project = ProjectModel.objects.get(pk=projectid)
except ObjectDoesNotExist as e:
return Response({"error": "Project with this id does not exist."})
serializer = ProjectSerializer(project)
return Response(serializer.data)
def get(self, request):
condition = {}
condition['user'] = User.objects.get(username=request.session['username'])
nid = request.GET.get('nid')
if not nid.startswith('999'):
condition['node'] = self.get_single(nid)
projects = Project.objects.filter(**condition)
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
def update_project(self, pk, data):
from api.serializers import ProjectSerializer
project = Project.objects.filter(pk=pk).first()
if not project:
return {'error': 'Проект не найден'}
serializer = ProjectSerializer(instance=project,
data=data,
partial=True)
if serializer.is_valid(raise_exception=False):
serializer.save()
project = serializer.instance
if not project.is_self:
from api.bot import BotNotification
if project.creator == self:
BotNotification.update_project(project)
if project.user == self:
BotNotification.accept_project(project)
return serializer.instance
print(serializer.errors)
return {'error': 'Ошибка сохранения проекта'}
def put(self, request, project_uuid):
user = request.user
group = get_user_group(user.username)
project = get_group_project(group, project_uuid)
if not project:
return Response("Project with UUID=%s does not "
"exist" % project_uuid,
status=status.HTTP_400_BAD_REQUEST)
data = request.DATA
serializer = ProjectSerializer(project, data=data,
context={"request": request})
if serializer.is_valid():
serializer.save()
response = Response(
serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, project_id):
"""
"""
user = request.user
data = request.DATA
group = get_user_group(user.username)
project = group.projects.filter(id=project_id)
if not project:
return Response("Project with ID=%s does not exist" % project_id,
status=status.HTTP_400_BAD_REQUEST)
project = project[0]
serializer = ProjectSerializer(project,
data=data,
context={"request": request})
if serializer.is_valid():
serializer.save()
response = Response(serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
"""
"""
user = request.user
group = get_user_group(user.username)
projects = group.projects.filter(only_current)
serialized_data = ProjectSerializer(projects,
many=True,
context={
"user": request.user
}).data
response = Response(serialized_data)
return response
def get(self, request, project_id=None):
HasUser.load(self, request)
try:
if project_id is None:
projects = Project.objects.filter(user=request.user)
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
else:
project = Project.objects.get(id=project_id)
if project.user != self.user:
raise PermissionDenied
serializer = ProjectSerializer(project)
return Response(serializer.data)
except Project.DoesNotExist:
raise NotFound
def put(self, request, project_id):
"""
"""
user = request.user
data = request.DATA
group = get_user_group(user.username)
project = group.projects.filter(id=project_id)
if not project:
return Response("Project with ID=%s does not exist" % project_id,
status=status.HTTP_400_BAD_REQUEST)
project = project[0]
serializer = ProjectSerializer(project, data=data,
context={"request":request})
if serializer.is_valid():
serializer.save()
response = Response(
serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
"""
"""
user = request.user
group = get_user_group(user.username)
projects = group.projects.filter(
Q(end_date=None) | Q(end_date__gt=timezone.now()))
serialized_data = ProjectSerializer(projects,
many=True,
context={
"request": request
}).data
response = Response(serialized_data)
return response
def patch(self, request, project_uuid):
"""
"""
user = request.user
group = get_user_group(user.username)
project = get_group_project(group, project_uuid)
if not project:
return Response("Project with UUID=%s does not exist" %
project_uuid,
status=status.HTTP_400_BAD_REQUEST)
data = request.DATA
serializer = ProjectSerializer(project,
data=data,
partial=True,
context={"request": request})
if serializer.is_valid():
serializer.save()
response = Response(serializer.data,
status=status.HTTP_201_CREATED)
return response
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_retrieve_tags(self):
"""Test retrieving project objects"""
Project.objects.create(
project="mdtouch",
about="centralized website",
feature="web and desktop apps",
tech_stack="django, python, angular, sql, android, pyQt5",
project_url="http://127.0.0.1:8080/api/projects/6",
user_profile=self.user)
res = self.client.get(PROJECT_URL)
project = Project.objects.all()
serializer = ProjectSerializer(project, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data['data'], serializer.data)
def get(self, request, project_id):
"""
"""
user = request.user
group = get_user_group(user.username)
project = group.projects.filter(id=project_id)
if not project:
return Response("Project with ID=%s does not exist" % project_id,
status=status.HTTP_400_BAD_REQUEST)
serialized_data = ProjectSerializer(project,
context={
"user": request.user
}).data
response = Response(serialized_data)
return response
def _project_create(self):
view = ProjectViewSet.as_view({'post': 'create'})
data = {'name': u'demo', 'owner': 'http://testserver/api/v1/users/bob'}
request = self.factory.post('/',
data=json.dumps(data),
content_type="application/json",
**self.extra)
response = view(request, owner='bob')
self.assertEqual(response.status_code, 201)
self.project = Project.objects.filter(name=data['name'])[0]
data['url'] = 'http://testserver/api/v1/projects/bob/%s'\
% self.project.pk
self.assertDictContainsSubset(data, response.data)
self.project_data = ProjectSerializer(self.project,
context={
'request': request
}).data
def recommended_projects(request):
user = User.objects.get(pk=request.user.id)
if user:
uni = user.userprofile.uni
location = user.userprofile.uni.location
skill_ids = [x.id for x in user.userprofile.skills.all()]
accuracy = 'high'
results = Project.objects.filter(
members__userprofile__uni__location = location,
req_skills__in = skill_ids,
).exclude(members=user)
if len(results) == 0:
results = Project.objects.filter(
req_skills__in = skill_ids
).exclude(members=user)
accuracy = 'medium'
if len(results) == 0:
results = Project.objects.filter(
members__userprofile__uni__location = location
).exclude(members=user)
accuracy = 'low'
serializer = ProjectSerializer(results, many=True, context={'request': request})
return Response({
'accuracy': accuracy,
'results': serializer.data,
'id' : request.user.id
}, status=status.HTTP_200_OK)
else:
return Response({
'error' : 'user not found'
}, status=status.HTTP_400_BAD_REQUEST)
def jwt_response_payload_handler(token, user=None, request=None):
try:
userdetail = applyApplication.objects.get(id=user.id)
userProject = 0
for project in Project.objects.all():
for member in project.members.all():
if member.id == user.id:
userProject = Project.objects.get(id=project.id)
break
except:
return {
'token': token,
'user': UserSerializer(user, context={'request': request}).data,
}
return {
'token': token,
'user': UserSerializer(user, context={'request': request}).data,
'userdetail':UserProfileSerializer(userdetail, context={'request':request}).data,
'userproject':ProjectSerializer(userProject, context={'request':request}).data
}
def delete(self, request, project_id):
"""
"""
user = request.user
group = get_user_group(user.username)
project = group.projects.filter(id=project_id)
if not project:
return Response("Project with ID=%s does not exist" % project_id,
status=status.HTTP_400_BAD_REQUEST)
project = project[0]
if project.name == 'Default':
return Response(
"The 'Default' project is reserved and cannot be deleted.",
status=status.HTTP_409_CONFLICT)
default_project = group.projects.get(name='Default')
project.copy_objects(default_project)
project.delete_project()
serialized_data = ProjectSerializer(project,
context={
"user": request.user
}).data
response = Response(serialized_data)
return response
def page(self, asker):
if (self.user and self.user != asker
and self.creator != asker) or self.canceled == asker:
return {'error': 'Ошибка загрузки проекта'}
from api.serializers import ProjectSerializer
result = {
'project': ProjectSerializer(self, asker=asker).data,
'calendar': {
'daysPick': self.dates
}
}
user = None
if self.user:
user = self.user
elif self.creator != asker:
user = asker
if user:
date_start = self.date_start or timezone.now()
start = date_start - timedelta(days=date_start.weekday(), weeks=15)
end = start + timedelta(weeks=68)
result['calendar'].update(
user.get_calendar(asker, start, end, project_id=self.id))
return result
def delete(self, request, project_id):
"""
"""
user = request.user
group = get_user_group(user.username)
project = group.projects.filter(id=project_id)
if not project:
return Response("Project with ID=%s does not exist" % project_id,
status=status.HTTP_400_BAD_REQUEST)
project = project[0]
running_resources = project.has_running_resources()
if running_resources:
return Response(
"Project %s has running resources. These resources "
"MUST be transferred or deleted before deleting the project." %
project.name,
status=status.HTTP_409_CONFLICT)
project.delete_project()
serialized_data = ProjectSerializer(project,
context={
"request": request
}).data
response = Response(serialized_data)
return response
def get(self, request, pk):
project = get_object_or_404(Project, pk=pk)
serializer = ProjectSerializer(data=project)
return Response(serializer.data)
def get(self, request):
projects = Project.objects.all()
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
def list(self, request):
queryset = Project.objects.all()
serializer = ProjectSerializer(queryset, many=True)
return Response(serializer.data)
