851 lines
32 KiB
Python
851 lines
32 KiB
Python
from django.views.decorators.csrf import ensure_csrf_cookie
|
|
from cloud.models import DataFile, DataDir
|
|
from django.shortcuts import redirect
|
|
from rest_framework.views import APIView
|
|
from rest_framework.response import Response
|
|
#from rest_framework.permissions import IsAuthenticated # <-- Here
|
|
import json
|
|
from standards.models import Standards
|
|
from rest_framework import serializers
|
|
from .serializers import StandardsSerializer, ChatRoomSerializer, ChatRoomFullSerializer
|
|
from rest_framework.decorators import api_view, permission_classes
|
|
from rest_framework import status
|
|
from rest_framework.authentication import SessionAuthentication, BasicAuthentication, TokenAuthentication
|
|
from rest_framework.decorators import authentication_classes
|
|
from chat.models import ChatRoom, ChatMessage
|
|
from django.http import HttpResponseRedirect,HttpResponse, JsonResponse
|
|
from django.contrib.sessions.models import Session
|
|
from timemanagement.models import Absence
|
|
from django.conf import settings
|
|
from digitaleagentur.utils import *
|
|
from timemanagement.models import Workday, FreeDays, Absence
|
|
from standards.models import Standards, NCFile
|
|
from users.models import AgencyGroup, Agency, AgencyNetwork, AgencyNetworkPreperation, UserTime, UserYearAbsenceInfo, AgencyBills
|
|
from standards.templatetags import *
|
|
|
|
class GetUserId(APIView):
|
|
#permission_classes = (IsAuthenticated,) # <-- And here
|
|
|
|
def post(self, request):
|
|
return Response({"userid" : self.request.user.pk})
|
|
|
|
|
|
@api_view(['POST', ])
|
|
#@permission_classes((IsAuthenticated,))
|
|
def getStandardList(request):
|
|
standards = Standards.objects.filter(agency=request.user.profile.agency)
|
|
ser = StandardsSerializer(standards, many=True)
|
|
return Response(ser.data, status=status.HTTP_200_OK)
|
|
|
|
@api_view(['POST', ])
|
|
#@permission_classes((IsAuthenticated,))
|
|
def getSingleStandard(request, pk):
|
|
standard = Standards.objects.get(pk=int(pk))
|
|
ser = StandardsSerializer(standard, many=False)
|
|
return Response(ser.data, status=status.HTTP_200_OK)
|
|
|
|
@api_view(['POST', ])
|
|
#@permission_classes((IsAuthenticated,))
|
|
def logoutByToken(request):
|
|
request.user.auth_token.delete()
|
|
return Response(status=status.HTTP_200_OK)
|
|
|
|
@api_view(['POST', ])
|
|
#@permission_classes((IsAuthenticated,))
|
|
def getchatrooms(request):
|
|
chatrooms = ChatRoom.objects.filter(creator=request.user) | ChatRoom.objects.filter(chatmember_single=request.user)
|
|
chatrooms_ser = ChatRoomSerializer(chatrooms, many=True)
|
|
return Response(chatrooms_ser.data, status=status.HTTP_200_OK)
|
|
|
|
|
|
@api_view(['POST', ])
|
|
#@permission_classes((IsAuthenticated,))
|
|
def getsinglechat(request, pk):
|
|
chatroom = ChatRoom.objects.get(pk=pk)
|
|
if chatroom.creator == request.user or chatroom.chatmember_single == request.user or (request.user in chatroom.chatmembers.all()):
|
|
chatroom_ser = ChatRoomFullSerializer(chatroom, many=False)
|
|
return Response(chatroom_ser.data, status=status.HTTP_200_OK)
|
|
else:
|
|
return Response(status=status.HTTP_403_FORBIDDEN)
|
|
|
|
|
|
@api_view(['POST', ])
|
|
#@permission_classes((IsAuthenticated,))
|
|
def savenewchatmessage(request):
|
|
room = ChatRoom.objects.get(pk=request.POST["room"])
|
|
if(request.user == room.creator or request.user == room.chatmember_single):
|
|
newmessage = ChatMessage(room=room, author=request.user, content=request.POST["message"])
|
|
newmessage.save()
|
|
room.messages.add(newmessage)
|
|
room.save()
|
|
return Response(status=status.HTTP_200_OK)
|
|
else:
|
|
return Response(status=status.HTTP_403_FORBIDDEN)
|
|
|
|
# IMPORTED MODELS FOR MIGRATION
|
|
from users.models import Agency
|
|
from django.contrib.auth.models import User
|
|
|
|
@api_view(['GET', ])
|
|
def migrateAgencyUsers(request, pk):
|
|
datapackage = {}
|
|
Ag = Agency.objects.get(pk=pk)
|
|
for user in User.objects.filter(profile__agency=Ag):
|
|
if(len(user.email) > 0 and len(user.first_name) > 0 and len(user.last_name) > 0):
|
|
datapackage.update({str(user.pk) : {"userid" : user.email, "displayname" : user.first_name + " " + user.last_name}})
|
|
return JsonResponse(datapackage)
|
|
|
|
|
|
|
|
|
|
@api_view(['GET', ])
|
|
def apilogout(request, uid):
|
|
print("LOGOUT: " + str(uid))
|
|
user = User.objects.get(username=uid)
|
|
user.profile.nc_sid = ""
|
|
user.save()
|
|
[s.delete() for s in Session.objects.all() if s.get_decoded().get('_auth_user_hash') == user.get_session_auth_hash()]
|
|
return JsonResponse({'res' : 'ok'})
|
|
|
|
|
|
# This function change the Username of a user, when it was changed in NextCloud! Works only for the own user :) !
|
|
import xmltodict, json, requests
|
|
@api_view(['GET'], )
|
|
def userChangedInNc(request, uid, sid):
|
|
user = User.objects.get(username=uid)
|
|
print("SID: " + sid)
|
|
if(user.is_authenticated and getNCLoggedUserBySession(sid) == uid):
|
|
nc_login_headers = {'Authorization' : 'Bearer ' + sid}
|
|
r = requests.get(settings.NEXTCLOUD_URL + "ocs/v1.php/cloud/users/" + uid, headers=nc_login_headers)
|
|
xpars = xmltodict.parse(r.text)
|
|
js = json.dumps(xpars)
|
|
final_json = json.loads(js)
|
|
new_displayname = final_json['ocs']['data']['displayname'].split(" ")
|
|
new_email = final_json['ocs']['data']['email']
|
|
user.email = new_email
|
|
user.first_name = new_displayname[0]
|
|
new_last_name = ""
|
|
new_displayname.pop(0)
|
|
for ele in new_displayname:
|
|
new_last_name += " " + ele
|
|
user.last_name = new_last_name
|
|
user.save()
|
|
return JsonResponse({"status" : "ok!"})
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
from requests.auth import HTTPBasicAuth
|
|
import random
|
|
import string
|
|
from django.contrib.auth.models import Group
|
|
from users.models import AgencyGroup
|
|
|
|
def get_random_number(length = 6):
|
|
result_str = ''.join(random.choice("0123456789") for i in range(length))
|
|
return result_str
|
|
|
|
def get_random_password(length = 6):
|
|
result_str = ''.join(random.choice("!_-abcdefghijklmnopqrstuvwxyzABCDEFGHIJLMNOPQRSTUVWXYZ0123456789") for i in range(length))
|
|
return result_str
|
|
|
|
# Returns a new groupID for NC by Groupname and Agency
|
|
def create_group_id(agencygroupname, agency):
|
|
newgroupid = ""
|
|
pregroupstr = "agencymaingroupid_"
|
|
if(agencygroupname == "Mitarbeiter"):
|
|
newgroupid = pregroupstr + str(agency.pk)
|
|
# NORMAL GROUOPS
|
|
elif(agencygroupname == "Administratoren"):
|
|
newgroupid = pregroupstr + str(agency.pk) + "_defaultadmingroup"
|
|
elif(agencygroupname == "Notfallhilfe"):
|
|
newgroupid = pregroupstr + str(agency.pk) + "_recover"
|
|
else:
|
|
newgroupid = pregroupstr + str(agency.pk) + "_subgroup_" + get_random_number()
|
|
|
|
return newgroupid
|
|
|
|
|
|
'''
|
|
Diese Methode erstellt die Gruppen in NC nach dem Schemata, wie sie auch bei einer Registrierung aufgebaut werden.
|
|
|
|
'''
|
|
@api_view(['GET'], )
|
|
def NCAddGroup(request):
|
|
if request.method == "GET":
|
|
|
|
group = Group.objects.get(name=request.GET.get('groupid'))
|
|
aggroup = AgencyGroup.objects.get(group=group)
|
|
agency = aggroup.agency
|
|
newgroupid = create_group_id(aggroup.agencygroupname, agency)
|
|
headers = {
|
|
'Accept' : 'application/json',
|
|
'Access-Control-Allow-Headers' : 'OCS-APIRequest',
|
|
'OCS-APIRequest' : 'true'
|
|
}
|
|
data = {
|
|
"groupid" : newgroupid
|
|
}
|
|
r = requests.post(settings.NEXTCLOUD_URL + "ocs/v1.php/cloud/groups", data=data, headers=headers, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
|
|
r_status = json.loads(r.text)
|
|
if(r_status['ocs']['meta']['statuscode'] == 100):
|
|
# Group created, save new group id in Django
|
|
aggroup.nc_name = newgroupid
|
|
aggroup.save()
|
|
|
|
# Group created, set display name in NC
|
|
data = {
|
|
"name": aggroup.agencygroupname,
|
|
"id" : newgroupid
|
|
}
|
|
r = requests.post(settings.NEXTCLOUD_URL + "ocs/v2.php/apps/da_agency/api/v1/renameagg?format=json", auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API), data=data)
|
|
return JsonResponse({'status' : True, 'message': 'Gruppe ' + aggroup.agencygroupname + ' erzeugt - ID: ' + newgroupid})
|
|
elif(r_status['ocs']['meta']['statuscode'] == 102):
|
|
return JsonResponse({'status' : True, 'message': 'Gruppe ' + aggroup.agencygroupname + ' (ID '+aggroup.group.name+') existiert bereits. Wird übersprungen. Bitte Namen prüfen!'})
|
|
else:
|
|
return JsonResponse({'status' : True, 'message': 'Gruppe ' + aggroup.agencygroupname + ' (ID '+aggroup.group.name+') konnte nicht erzeugt werden. Bitte manuell prüfen'})
|
|
#except:
|
|
# return JsonResponse({'status' : True, 'message': 'Gruppe ' + aggroup.agencygroupname + ' (ID '+aggroup.group.name+') konnte nicht erzeugt werden. Bitte manuell prüfen' + r.text})
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
|
|
'''
|
|
Hier werden die Nutzer angelegt.
|
|
'''
|
|
@api_view(['GET'], )
|
|
def NCAddUser(request):
|
|
if request.method == "GET":
|
|
agency = Agency.objects.get(pk=request.GET.get('agencyid'))
|
|
user = User.objects.get(pk=request.GET['userid'])
|
|
# Check, that only users in the same agency can do that!
|
|
if(user.profile.agency == agency):
|
|
# Load all groups the User is in and get AgencyGroup for NC-Group-Name
|
|
groups = []
|
|
for g in user.groups.all():
|
|
groups.append(AgencyGroup.objects.get(group=g).nc_name)
|
|
|
|
#password = get_random_password(50)
|
|
password = ""
|
|
userid = user.username
|
|
displayName = user.first_name + " " + user.last_name
|
|
email = user.email
|
|
|
|
# Data for the new User
|
|
data = {
|
|
"userid": userid,
|
|
"password": password,
|
|
"displayName": displayName,
|
|
"email":email,
|
|
"groups[]":groups,
|
|
"quota": 104857600
|
|
}
|
|
|
|
headers = {
|
|
'Accept' : 'application/json',
|
|
'Access-Control-Allow-Headers' : 'OCS-APIRequest',
|
|
'OCS-APIRequest' : 'true'
|
|
}
|
|
|
|
# Request for adding the new User
|
|
r = requests.post(settings.NEXTCLOUD_URL + "ocs/v1.php/cloud/users", data=data, headers=headers, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
try:
|
|
r_status = json.loads(r.text)
|
|
if(r_status['ocs']['meta']['statuscode'] == 100):
|
|
return JsonResponse({'status' : True, 'message': 'Benutzer ' + user.first_name + " " + user.last_name + ' angelegt und in die Gruppen gepackt.'})
|
|
else:
|
|
return JsonResponse({'status' : True, 'message': 'Benutzer ' + user.first_name + " " + user.last_name + ' konnte nicht angelegt werden. Bitte manuell prüfen!', 'message' : r.text})
|
|
except:
|
|
return JsonResponse({'status' : True, 'message': 'Benutzer ' + user.first_name + " " + user.last_name + ' konnte nicht angelegt werden. Bitte manuell prüfen!', 'message' : r.text})
|
|
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
@api_view(['GET'],)
|
|
def getTMInfos(request, uid, secretkey):
|
|
if request.method == "GET":
|
|
return JsonResponse({"status" : "DATA " + uid + " " + secretkey})
|
|
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
from requests.auth import HTTPBasicAuth
|
|
'''
|
|
Anlegen des Gruppenordners der Agentur in NC
|
|
|
|
WIRD NICHT VERWENDET!!!
|
|
'''
|
|
@api_view(['POST'], )
|
|
def NCAddGroupFolder(request):
|
|
if request.method == "POST":
|
|
agency = Agency.objects.get(pk=request.POST.get('agencyid'))
|
|
data = {
|
|
"gid" : "agencymaingroupid_" + str(agency.pk),
|
|
"aid" : str(agency.pk),
|
|
"sk'" : settings.NC_SECRETKEY
|
|
}
|
|
headers = {
|
|
'Authorization': 'Bearer ' + request.user.profile.nc_sid
|
|
}
|
|
# Groupfolder
|
|
r = requests.post(settings.NEXTCLOUD_URL + "apps/agency/createagf", data=data, headers=headers)
|
|
|
|
# Standard Folder
|
|
r = requests.request("MKCOL", settings.NEXTCLOUD_URL + "remote.php/dav/files/" + settings.NEXTCLOUD_USER_API + "/Agenturdaten_" + str(agency.pk)+ '/Standards Uploadbereich/', auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
|
|
return JsonResponse({'status' : True, 'message': 'Gruppenordner und Standard-Ordner angelegt!' + r.text})
|
|
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
import os
|
|
|
|
'''
|
|
Hier werden die Dateien angelegt und entsprechende Zugriffsrechte der Gruppen gesetzt.
|
|
'''
|
|
@api_view(['GET'], )
|
|
def NCAddFiles(request):
|
|
if request.method == "GET":
|
|
agency = Agency.objects.get(pk=request.GET.get('agencyid'))
|
|
file_to_load = DataFile.objects.get(pk=request.GET.get('fileid'))
|
|
datadir_parent = None
|
|
datadir_parent_dirnames = []
|
|
if(file_to_load.parent != None):
|
|
datadir_parent = file_to_load.parent
|
|
datadir_parent_dirnames = [file_to_load.parent.name]
|
|
|
|
while(datadir_parent.parent != None):
|
|
datadir_parent_dirnames.append(datadir_parent.parent.name)
|
|
datadir_parent = datadir_parent.parent
|
|
## Popping last Element
|
|
d_prestring = ""
|
|
if(len(datadir_parent_dirnames) > 0):
|
|
datadir_parent_dirnames.pop(len(datadir_parent_dirnames)-1)
|
|
# Turning Array around
|
|
datadir_parent_dirnames = datadir_parent_dirnames[::-1]
|
|
|
|
# Dirs needed for the File
|
|
for d in datadir_parent_dirnames:
|
|
new_folder = d_prestring + "/" +d
|
|
r = requests.request("MKCOL", settings.NEXTCLOUD_URL + "remote.php/dav/files/vhdadjangoapi_8fjz47epc6/Agenturdaten_" + str(agency.pk)+ '/' + new_folder, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
d_prestring += "/" + d
|
|
|
|
# Uplod the file!
|
|
final_file_path = settings.NEXTCLOUD_URL + "remote.php/dav/files/vhdadjangoapi_8fjz47epc6/Agenturdaten_"+ str(agency.pk) + "/" + d_prestring + "/" + file_to_load.name
|
|
with open(file_to_load.file.path, 'rb') as f:
|
|
r = requests.put(final_file_path, data=f, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
if(len(r.text) == 0):
|
|
return JsonResponse({'status' : True, 'message': 'Datei ' + file_to_load.name + ' angelegt.'})
|
|
else:
|
|
return JsonResponse({'status' : True, 'message': 'Datei ' + file_to_load.name + ' konnte nicht angelegt. Bitte manuell prüfen!'})
|
|
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
'''
|
|
STANDARD FILES
|
|
'''
|
|
@api_view(['GET'], )
|
|
def NCAddStandardFiles(request):
|
|
if request.method == "GET":
|
|
agency = Agency.objects.get(pk=request.GET.get('agencyid'))
|
|
file_to_load = DataFile.objects.get(pk=request.GET.get('fileid'))
|
|
|
|
# Uplod the file!
|
|
final_file_path = settings.NEXTCLOUD_URL + "remote.php/dav/files/vhdadjangoapi_8fjz47epc6/Agenturdaten_"+ str(agency.pk) + "/Standards Uploadbereich/" + file_to_load.name
|
|
with open(file_to_load.file.path, 'rb') as f:
|
|
r = requests.put(final_file_path, data=f, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
|
|
if(len(r.text) == 0):
|
|
return JsonResponse({'status' : True, 'message': 'Datei ' + file_to_load.name + ' angelegt.'})
|
|
else:
|
|
return JsonResponse({'status' : True, 'message': 'Datei ' + file_to_load.name + ' konnte nicht angelegt. Bitte manuell prüfen!'})
|
|
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
|
|
'''
|
|
Hier werden die Dateien angelegt und entsprechende Zugriffsrechte der Gruppen gesetzt.
|
|
'''
|
|
@api_view(['GET'], )
|
|
def NCAddDirs(request):
|
|
if request.method == "GET":
|
|
agency = Agency.objects.get(pk=request.GET.get('agencyid'))
|
|
dir_to_create = DataDir.objects.get(pk=request.GET.get('dirid'))
|
|
sharestring = ""
|
|
if(dir_to_create.visibleby.all().count() > 0):
|
|
sharestring = " Ordner nur sichtbar durch: "
|
|
for cd in dir_to_create.visibleby.all():
|
|
sharestring += cd.agencygroupname + " (" + cd.nc_name + ")"
|
|
# Dir has no parent, create
|
|
if(len(dir_to_create.parent.name) == 0):
|
|
r = requests.request("MKCOL", settings.NEXTCLOUD_URL + "remote.php/dav/files/vhdadjangoapi_8fjz47epc6/Agenturdaten_" + str(agency.pk)+ '/' + dir_to_create.name, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
return JsonResponse({'status' : True, 'message': 'Ordner ' + dir_to_create.name + ' angelegt. ' + sharestring + " RESP: " + r.text})
|
|
# Dir has parents, start thinking :)
|
|
else:
|
|
datadir_parent = None
|
|
datadir_parent_dirnames = []
|
|
if(dir_to_create.parent != None and len(dir_to_create.parent.name) > 0):
|
|
datadir_parent = dir_to_create.parent
|
|
datadir_parent_dirnames = [dir_to_create.parent.name]
|
|
|
|
if(datadir_parent.parent != None):
|
|
while(datadir_parent.parent != None and len(datadir_parent.parent.name) > 0):
|
|
datadir_parent_dirnames.append(datadir_parent.parent.name)
|
|
datadir_parent = datadir_parent.parent
|
|
|
|
if(len(datadir_parent_dirnames) > 0):
|
|
datadir_parent_dirnames = datadir_parent_dirnames[::-1]
|
|
d_prestring = ""
|
|
for d in datadir_parent_dirnames:
|
|
new_folder = d_prestring + "/" +d
|
|
r = requests.request("MKCOL", settings.NEXTCLOUD_URL + "remote.php/dav/files/vhdadjangoapi_8fjz47epc6/Agenturdaten_" + str(agency.pk)+ '/' + new_folder, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
d_prestring += "/" + d
|
|
|
|
r = requests.request("MKCOL", settings.NEXTCLOUD_URL + "remote.php/dav/files/vhdadjangoapi_8fjz47epc6/Agenturdaten_" + str(agency.pk)+ d_prestring + "/" + dir_to_create.name, auth=(settings.NEXTCLOUD_USER_API, settings.NEXTCLOUD_PW_API))
|
|
|
|
return JsonResponse({'status' : True, 'message': 'Ordner ' + dir_to_create.name + ' angelegt.' + sharestring + " RESP: " + r.text + " " + "remote.php/dav/files/vhdadjangoapi_8fjz47epc6/Agenturdaten_" + str(agency.pk) + d_prestring + "/" + dir_to_create.name})
|
|
|
|
|
|
return JsonResponse({'status' : False, 'message': 'AUTH ERROR'})
|
|
|
|
@api_view(['GET'], )
|
|
def NCTest(request):
|
|
#print(request.headers)
|
|
return JsonResponse({'status' : False, 'message': 'AUTH ERROR'})
|
|
|
|
# Setting the Users Data for logging
|
|
@api_view(['POST'], )
|
|
def SetUserData(request):
|
|
try:
|
|
user = User.objects.get(username=request.POST.get('uid'))
|
|
user.profile.nc_sid = request.POST.get('sid')
|
|
user.save()
|
|
return JsonResponse({'message' : 'A user was found in request, sid set!'})
|
|
except:
|
|
return JsonResponse({'message' : 'USER NOT FOUND'})
|
|
|
|
|
|
|
|
|
|
def getFileIdFromXML(xmlresponse):
|
|
try:
|
|
split_response = xmlresponse.split("<oc:fileid>")
|
|
split_fileele = split_response[1].split("<")
|
|
return split_fileele[0]
|
|
except:
|
|
return None
|
|
|
|
|
|
'''
|
|
Standardateien neu zuweisen
|
|
|
|
Pro Datei in addedfiles wird ein neues NCFile-Objekt erstellt und in addedfiles_nc gespeichert. In den Ansichten der Standards werden dann nur noch die addedfiles_nc-Elemente gesehen und verändert.
|
|
'''
|
|
import re, json
|
|
from urllib.parse import unquote
|
|
@api_view(['GET'], )
|
|
def NCSwitchStandardFiles(request):
|
|
if request.method == "GET":
|
|
standard = Standards.objects.get(pk=request.GET.get('standardid'))
|
|
response_status = "OK"
|
|
# Dateien aus NC laden
|
|
# TODO: HIER WIEDER DEN USER EINTRAGEN vhdarootadmin_2cdme7ckw
|
|
filesearchdata = '<?xml version="1.0" encoding="UTF-8"?><d:searchrequest xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns"><d:basicsearch><d:select><d:prop><oc:fileid/></d:prop></d:select><d:from><d:scope><d:href>/files/vhdarootadmin_2cdme7ckw' + '/Agenturdaten_' + str(standard.agency.pk) + '/</d:href><d:depth>infinity</d:depth></d:scope></d:from><d:where><d:gt><d:prop><oc:size/></d:prop><d:literal>1</d:literal></d:gt></d:where></d:basicsearch></d:searchrequest>'
|
|
|
|
#filesearchdata = '<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns"><d:prop><oc:fileid /></d:prop><d:depth>infinity</d:depth></d:propfind>'
|
|
r = requests.request("SEARCH", settings.NEXTCLOUD_URL + "remote.php/dav/", data=filesearchdata, headers={'Content-Type' : 'text/xml', 'Authorization' : "Bearer " + request.user.profile.nc_sid})
|
|
print(r.text)
|
|
# IDs filtern aus XML-Response
|
|
#print(r.text)
|
|
ncfileids = [str(s) for s in re.findall('<d:response>(.+?)</d:response>', r.text)]
|
|
final_nc_files = []
|
|
# IDs from the User
|
|
for ele in ncfileids:
|
|
nc_filename_with_path = [str(s) for s in re.findall('<d:href>(.+?)</d:href>', ele)][0]
|
|
nc_filename_with_path = nc_filename_with_path.split("/")
|
|
|
|
filename = nc_filename_with_path[len(nc_filename_with_path)-1]
|
|
|
|
nc_file_id = [str(s) for s in re.findall('<oc:fileid>(.+?)</oc:fileid>', ele)][0]
|
|
|
|
if(len(filename) > 0):
|
|
final_nc_files.append([nc_file_id, unquote(filename, errors="strict")])
|
|
|
|
# Reset der NC-Files
|
|
for nc_standard_file in standard.addedfiles_nc.all():
|
|
nc_standard_file.delete()
|
|
|
|
standard.addedfiles_nc.clear()
|
|
standard.save()
|
|
|
|
for f in standard.addedfiles.all():
|
|
for nc_file_ele in final_nc_files:
|
|
print(f.name + " NAME " + nc_file_ele[1])
|
|
if(f.name == nc_file_ele[1]):
|
|
ncfile = NCFile.objects.create(agency=standard.agency, nc_id=nc_file_ele[0], file_id=f)
|
|
standard.addedfiles_nc.add(ncfile)
|
|
response_status += " DATEI " + f.name + " ZU STANDARD " + str(standard.pk) + " zugeordnet. - NC FILE ID " + str(nc_file_ele[0])
|
|
print("ZUGEORDNET!")
|
|
return JsonResponse({"status" : response_status})
|
|
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
'''
|
|
if request.method == "GET":
|
|
|
|
#agency = Agency.objects.get(pk=request.GET.get('agencyid'))
|
|
|
|
jsonresponse = json.dumps(request.GET)
|
|
json_final = json.loads(jsonresponse)
|
|
standardid = False
|
|
ncfiledata = False
|
|
elejson = ""
|
|
|
|
for ele in json_final:
|
|
elejson = json.loads(ele)
|
|
standardid = elejson[0][1]
|
|
|
|
ncfiledata = elejson[1]['ncfiledata']
|
|
|
|
response_status = "OK"
|
|
standard = Standards.objects.get(pk=standardid)
|
|
|
|
# Reset der NC-Files
|
|
for nc_standard_file in standard.addedfiles_nc.all():
|
|
nc_standard_file.delete()
|
|
|
|
standard.addedfiles_nc.clear()
|
|
standard.save()
|
|
|
|
for f in standard.addedfiles.all():
|
|
for nc_file_ele in ncfiledata:
|
|
print(f.name + " NAME " + nc_file_ele[1])
|
|
if(f.name == nc_file_ele[1]):
|
|
ncfile = NCFile.objects.create(agency=standard.agency, nc_id=nc_file_ele[0], file_id=f)
|
|
standard.addedfiles_nc.add(ncfile)
|
|
response_status += " DATEI " + f.name + " ZU STANDARD " + str(standard.pk) + " zugeordnet. - NC FILE ID " + str(nc_file_ele[0])
|
|
|
|
return JsonResponse({"status" : response_status})
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
'''
|
|
|
|
@api_view(['GET'], )
|
|
def NCGetFilesForStandardSwitch(request):
|
|
if request.method == "GET":
|
|
#agency = Agency.objects.get(pk=request.GET.get('agencyid'))
|
|
standard = Standards.objects.get(pk=request.GET.get('standardid'))
|
|
|
|
# Dateien aus NC laden
|
|
filesearchdata = '<?xml version="1.0" encoding="UTF-8"?><d:searchrequest xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns"><d:basicsearch><d:select><d:prop><oc:fileid/></d:prop></d:select><d:from><d:scope><d:href>/files/vhdarootadmin_2cdme7ckw' + '/Agenturdaten_' + str(standard.agency.pk) + '/</d:href><d:depth>infinity</d:depth></d:scope></d:from><d:where><d:gt><d:prop><oc:size/></d:prop><d:literal>1</d:literal></d:gt></d:where></d:basicsearch></d:searchrequest>'
|
|
|
|
#filesearchdata = '<?xml version="1.0" encoding="UTF-8"?><d:propfind xmlns:d="DAV:" xmlns:oc="http://owncloud.org/ns"><d:prop><oc:fileid /></d:prop><d:depth>infinity</d:depth></d:propfind>'
|
|
r = requests.request("SEARCH", settings.NEXTCLOUD_URL + "remote.php/dav/", data=filesearchdata, headers={'Content-Type' : 'text/xml', 'Authorization' : "Bearer " + request.user.profile.nc_sid})
|
|
# IDs filtern aus XML-Response
|
|
#print(r.text)
|
|
ncfileids = [str(s) for s in re.findall('<d:response>(.+?)</d:response>', r.text)]
|
|
final_nc_files = []
|
|
# IDs from the User
|
|
for ele in ncfileids:
|
|
nc_filename_with_path = [str(s) for s in re.findall('<d:href>(.+?)</d:href>', ele)][0]
|
|
nc_filename_with_path = nc_filename_with_path.split("/")
|
|
|
|
filename = nc_filename_with_path[len(nc_filename_with_path)-1]
|
|
|
|
nc_file_id = [str(s) for s in re.findall('<oc:fileid>(.+?)</oc:fileid>', ele)][0]
|
|
|
|
if(len(filename) > 0):
|
|
final_nc_files.append([nc_file_id, filename])
|
|
|
|
return JsonResponse({"ncfiledata" : final_nc_files})
|
|
|
|
|
|
|
|
@api_view(['GET'], )
|
|
def deleteNCFile(request, fid, secretkey):
|
|
if request.method == "GET":
|
|
if(secretkey == '87zuhjk87GHJ546tzgvhas76aaskbdhr45edfVHAKia87s6gbAVGFGSR3451627gBHAKJBN'):
|
|
try:
|
|
file_to_del = NCFile.objects.filter(nc_id=fid).first()
|
|
file_to_del.delete()
|
|
except:
|
|
pass
|
|
return JsonResponse({"status" : 'true'})
|
|
else:
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
else:
|
|
return JsonResponse({"status" : "NO AUTH"})
|
|
|
|
# APIs for TIMEMANAGEMENT
|
|
@api_view(['GET'], )
|
|
def startWorkDay(request, uid, secretkey):
|
|
if request.method == "GET" and secretkey == '87zuhjk87GHJ546tzgvhas76aaskbdhr45edfVHAKia87s6gbAVGFGSR3451627gBHAKJBN':
|
|
|
|
username_new = uid.replace("REPLACEDATAELEMENTVER0000000001", "@")
|
|
username_new = username_new.replace("POINTPOINTPOINTPOINTPOINTPOINT", ".")
|
|
|
|
user = User.objects.filter(username=username_new).first()
|
|
|
|
today = date.today()
|
|
targettime = 0.0
|
|
if(today.isoweekday() == 1):
|
|
targettime = user.usertime.wd_mo
|
|
elif(today.isoweekday() == 2):
|
|
targettime = user.usertime.wd_tu
|
|
elif(today.isoweekday() == 3):
|
|
targettime = user.usertime.wd_we
|
|
elif(today.isoweekday() == 4):
|
|
targettime = user.usertime.wd_th
|
|
elif(today.isoweekday() == 5):
|
|
targettime = user.usertime.wd_fr
|
|
elif(today.isoweekday() == 6):
|
|
targettime = user.usertime.wd_sa
|
|
elif(today.isoweekday() == 7):
|
|
targettime = user.usertime.wd_so
|
|
|
|
# Liegt eine halbe Abwesenheit vor, wird hier die Zielarbeitszeit halbiert
|
|
if(getAbsenceForOneDay(user, today) != False):
|
|
targettime = targettime / 2
|
|
|
|
# Prpfung, ob bereits Arbeitstage an diesem Tag vorliegen
|
|
tempworkday = Workday.objects.filter(agency=user.profile.agency, user=user, start__day=today.day, start__month=today.month, start__year=today.year, delflag = False)
|
|
|
|
|
|
user_has_workdays = False
|
|
if len(tempworkday) == 0:
|
|
# Noch kein Arbeitstag vorhanden, Zielarbeitszeit ganz normal
|
|
user_has_workdays = True
|
|
else:
|
|
# Es ist bereits ein ARbeitstag vorhanden, daher wird die Zielarbeitszeit des zweiten Teils auf 0 gesetzt
|
|
targettime=0.0
|
|
|
|
|
|
wd = Workday(user=user, agency=user.profile.agency, start=timezone.now(), target=targettime)
|
|
wd.save()
|
|
|
|
data = {
|
|
"success" : True,
|
|
"wd_starttime" : wd.start.strftime("%H:%M:%S"),
|
|
"wd_starttime_complete" : wd.start
|
|
}
|
|
|
|
return JsonResponse(data)
|
|
else:
|
|
return JsonResponse({"status" : "FALSE"})
|
|
|
|
# APIs for TIMEMANAGEMENT
|
|
import os
|
|
from django.conf import settings
|
|
from django.utils import timezone
|
|
from datetime import date
|
|
import datetime
|
|
# Ladet das aktuelle Gleitzeitkonto
|
|
'''
|
|
|
|
Es werden nur Tage berücksichtigt, die in der Vergangenheit liegen!
|
|
|
|
'''
|
|
def format_timedelta(td):
|
|
hours, remainder = divmod(td.total_seconds(), 3600)
|
|
minutes, seconds = divmod(remainder, 60)
|
|
hours, minutes, seconds = int(hours), int(minutes), int(seconds)
|
|
if hours < 10:
|
|
hours = '0%s' % int(hours)
|
|
if minutes < 10:
|
|
minutes = '0%s' % minutes
|
|
if seconds < 10:
|
|
seconds = '0%s' % seconds
|
|
return '%s:%s:%s' % (hours, minutes, seconds)
|
|
|
|
def loadaccounttime(user):
|
|
status = 0
|
|
today = date.today()
|
|
workdays = Workday.objects.filter(user=user, start__lt=today, delflag = False).exclude(end=None)
|
|
|
|
finalaccounttimesum = datetime.timedelta(minutes=0) + datetime.timedelta(hours=UserTime.objects.get(user=user).startcount)
|
|
|
|
|
|
for workday in workdays:
|
|
# Zeit, die der Mitarbeiter gearbeitet haben MUSS
|
|
|
|
sum_break = 0
|
|
|
|
if(len(workday.breaks.all()) > 0):
|
|
|
|
for ele in workday.breaks.all():
|
|
if ele.end != None and ele.start != None:
|
|
sum_break += (ele.end - ele.start).seconds
|
|
|
|
finalsum = ((workday.end - workday.start).seconds - sum_break)
|
|
hastowork = datetime.timedelta(hours=workday.target)
|
|
final_info = (int(finalsum) - int(hastowork.total_seconds()))/60
|
|
|
|
if(final_info >= 0.0):
|
|
finalaccounttimesum += datetime.timedelta(minutes=final_info)
|
|
else:
|
|
final_info = final_info * -1
|
|
finalaccounttimesum -= datetime.timedelta(minutes=final_info)
|
|
|
|
# Gesamtgleitzeit einmal schick darstellen mit rot und grün
|
|
# Wenn GLeitzeit NEGATIV ist
|
|
if(finalaccounttimesum.total_seconds() < 0):
|
|
status = 1
|
|
final_info_data = format_timedelta(datetime.timedelta(seconds=finalaccounttimesum.total_seconds()*(-1)))
|
|
else:
|
|
status = 0
|
|
final_info_data = format_timedelta(datetime.timedelta(seconds=finalaccounttimesum.total_seconds()))
|
|
|
|
final_info_data_neu = final_info_data.split(":")[0] + ":" + final_info_data.split(":")[1]
|
|
|
|
#final_info = str(final_info_data[0]) + ":" + str(final_info_data[1])
|
|
return [final_info_data_neu, status]
|
|
|
|
|
|
'''
|
|
Gibt alle aktuellen Zeitdaten zurück:
|
|
- Aktuelles Gleitzeitkonto
|
|
- Ob ein aktueller Arbeitstag vorliegt (wenn ja, dann die entsprechenden Daten)
|
|
|
|
'''
|
|
@api_view(['GET'], )
|
|
def getTime(request, uid, secretkey):
|
|
if request.method == "GET" and secretkey == '87zuhjk87GHJ546tzgvhas76aaskbdhr45edfVHAKia87s6gbAVGFGSR3451627gBHAKJBN':
|
|
|
|
username_new = uid.replace("REPLACEDATAELEMENTVER0000000001", "@")
|
|
username_new = username_new.replace("POINTPOINTPOINTPOINTPOINTPOINT", ".")
|
|
|
|
user = User.objects.filter(username=username_new).first()
|
|
|
|
usetime = True
|
|
|
|
if(user.usertime!= None and user.usertime.usetime == False):
|
|
usetime = False
|
|
|
|
wd = Workday.objects.filter(user=user, agency=user.profile.agency, end=None, delflag = False)
|
|
workdaydata_workday = 0
|
|
workdaydata_starttime = 0
|
|
breakstatus = False
|
|
breaktimer = 0
|
|
breaksum = 0
|
|
|
|
if(len(wd) > 0):
|
|
wd_second = list(Workday.objects.filter(user=user, agency=user.profile.agency, end=None, delflag = False))[0]
|
|
workdaydata_workday = list(wd)[0].start
|
|
workdaydata_starttime = wd_second.start.strftime("%H:%M:%S")
|
|
|
|
|
|
for b in wd_second.breaks.all():
|
|
if(b.end != None):
|
|
breaksum += (b.end - b.start).seconds
|
|
|
|
breaksum = breaksum*1000
|
|
|
|
|
|
# Check for Breaks
|
|
if(len(wd_second.breaks.all()) > 0):
|
|
# Check if all Breaks ended
|
|
wdbreak = wd_second.breaks.filter(end=None)
|
|
if(len(wdbreak) > 0):
|
|
breakstatus = True
|
|
|
|
|
|
# Break Found, return actual breakcounter
|
|
if(breakstatus):
|
|
wdbreak = wd_second.breaks.filter(end=None)
|
|
if(len(wdbreak) > 0):
|
|
now = timezone.now()
|
|
breakstart = list(wdbreak)[0].start
|
|
breaktimer = (now - breakstart).seconds * 1000
|
|
|
|
return JsonResponse({'actualtime' : loadaccounttime(user)[0], 'workdaydata_workday' : workdaydata_workday, 'workdaydata_starttime' : workdaydata_starttime, 'breakstatus' : breakstatus, 'breaktimer' : breaktimer, 'breaksum' : breaksum, 'usetime' : usetime})
|
|
|
|
else:
|
|
return ({"status" : "FALSE"})
|
|
|
|
|
|
# APIs for TIMEMANAGEMENT
|
|
# End a WorkDay
|
|
@api_view(['GET'], )
|
|
def endWorkDay(request, uid, secretkey):
|
|
if request.method == "GET" and secretkey == '87zuhjk87GHJ546tzgvhas76aaskbdhr45edfVHAKia87s6gbAVGFGSR3451627gBHAKJBN':
|
|
|
|
username_new = uid.replace("REPLACEDATAELEMENTVER0000000001", "@")
|
|
username_new = username_new.replace("POINTPOINTPOINTPOINTPOINTPOINT", ".")
|
|
|
|
user = User.objects.filter(username=username_new).first()
|
|
|
|
wd = list(Workday.objects.filter(user=user, agency=user.profile.agency, end=None, delflag = False))[0]
|
|
# END ALL BREAKS
|
|
for b in wd.breaks.all():
|
|
if b.end == None:
|
|
b.end = timezone.now()
|
|
b.save()
|
|
wd.end = timezone.now()
|
|
wd.save()
|
|
|
|
breaksum = 0
|
|
for b in wd.breaks.all():
|
|
if(b.end != None):
|
|
breaksum += (b.end - b.start).seconds
|
|
|
|
data = {
|
|
"success" : True,
|
|
"wd_endtime" : wd.end.strftime("%H:%M:%S"),
|
|
"actualbreaktime" : breaksum*1000
|
|
}
|
|
|
|
return JsonResponse(data)
|
|
else:
|
|
return JsonResponse({"status" : "FALSE"})
|
|
|
|
# Start Break
|
|
@api_view(['GET'], )
|
|
def startBreak(request, uid, secretkey):
|
|
if request.method == "GET" and secretkey == '87zuhjk87GHJ546tzgvhas76aaskbdhr45edfVHAKia87s6gbAVGFGSR3451627gBHAKJBN':
|
|
|
|
username_new = uid.replace("REPLACEDATAELEMENTVER0000000001", "@")
|
|
username_new = username_new.replace("POINTPOINTPOINTPOINTPOINTPOINT", ".")
|
|
|
|
user = User.objects.filter(username=username_new).first()
|
|
|
|
wd = list(Workday.objects.filter(user=user, agency=user.profile.agency, end=None, delflag = False))[0]
|
|
newbreak = Breaks(workday=wd, user=user, agency=user.profile.agency, start=timezone.now())
|
|
newbreak.save()
|
|
wd.breaks.add(newbreak)
|
|
data = {
|
|
"success" : True,
|
|
"break_starttime" : newbreak.start,
|
|
}
|
|
return JsonResponse(data)
|
|
else:
|
|
return JsonResponse({"status" : "FALSE"})
|
|
|
|
# End Break
|
|
@api_view(['GET'], )
|
|
def endBreak(request, uid, secretkey):
|
|
if request.method == "GET" and secretkey == '87zuhjk87GHJ546tzgvhas76aaskbdhr45edfVHAKia87s6gbAVGFGSR3451627gBHAKJBN':
|
|
|
|
username_new = uid.replace("REPLACEDATAELEMENTVER0000000001", "@")
|
|
username_new = username_new.replace("POINTPOINTPOINTPOINTPOINTPOINT", ".")
|
|
|
|
user = User.objects.filter(username=username_new).first()
|
|
|
|
|
|
wd = list(Workday.objects.filter(user=user, agency=user.profile.agency, end=None, delflag = False))[0]
|
|
toendbreak = list(wd.breaks.filter(end=None))[0]
|
|
toendbreak.end = timezone.now()
|
|
toendbreak.save()
|
|
|
|
wd = list(Workday.objects.filter(user=user, agency=user.profile.agency, end=None, delflag = False))[0]
|
|
breaksum = 0
|
|
for b in wd.breaks.all():
|
|
if(b.end != None):
|
|
breaksum += (b.end - b.start).seconds
|
|
|
|
data = {
|
|
"success" : True,
|
|
"actualbreaktime" : breaksum*1000,
|
|
"wdtime" : wd.start
|
|
}
|
|
return JsonResponse(data)
|
|
else:
|
|
return JsonResponse({"status" : "FALSE"})
|
|
|
|
|
|
|
|
|
|
|