def moveFile(request, user, fileid, newfolderid):
"""Verschiebt eine Datei in einen anderen Ordner.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der Datei welche verschoben werden soll
:param newfolderid: Id des Ordners, in welchen die Datei verschoben werden soll
:return: HttpResponse (JSON)
"""
# hole das folder und file object
folderobj = Folder.objects.get(id=newfolderid)
fileobj = File.objects.get(id=fileid)
# Teste ob eine Datei mit dem selben Namen schon existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(fileobj.name, File, folderobj, request)
# Man darf eine Datei in dieselbes Verzeichnis verschieben (dann passiert einfach nichts)
if not unique and folderobj != fileobj.folder:
return failurereturn
# versuche den neuen Ordner des fileobj zu setzen
try:
fileobj.folder = folderobj
fileobj.save()
return util.jsonResponse({'id': fileobj.id,
'name': fileobj.name,
'folderid': fileobj.folder.id,
'foldername': fileobj.folder.name,
'rootid': fileobj.folder.getRoot().id}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def getText(request, user, fileid):
"""Liefert eine vom Client angeforderte Text Datei als JSON.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der Text Datei welcher heruntergeladen werden soll
:return: HttpResponse (JSON)
"""
# hole das tex Datei Objekt
plaintextobj = PlainTextFile.objects.get(id=fileid)
isallowedit = not plaintextobj.isLocked() or plaintextobj.lockedBy() == user
if isallowedit:
plaintextobj.lock(user)
lasteditor = ""
if plaintextobj.lasteditor:
lasteditor = plaintextobj.lasteditor.username
dictionary = {
'fileid': plaintextobj.id,
'filename': plaintextobj.name,
'rootid': plaintextobj.folder.getRoot().id,
'content': plaintextobj.source_code,
'lastmodifiedtime': util.datetimeToString(plaintextobj.lastModifiedTime),
'isallowedit': isallowedit,
'lasteditor': lasteditor
}
return util.jsonResponse(dictionary, True, request)
def renameFile(request, user, fileid, newfilename):
"""Benennt eine vom Client angegebene Datei um.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der Datei welche umbenannt werden soll
:param newfilename: neuer Dateiname
:return: HttpResponse (JSON)
"""
# hole das file object
fileobj = File.objects.get(id=fileid)
# Teste ob eine Datei mit dem selben Namen schon existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(newfilename, File, fileobj.folder, request)
if not unique:
return failurereturn
# versuche den neuen Dateinamen zu setzen
try:
fileobj.name = newfilename
fileobj.save()
return util.jsonResponse({'id': fileobj.id, 'name': fileobj.name}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def createDir(request, user, parentdirid=0, directoryname=""):
"""Erstellt einen neuen Ordner im angegebenen Verzeichnis.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param parentdirid: Id des übergeordneten Ordners
:param directoryname: Name des zu erstellenden Ordners
:return: HttpResponse (JSON)
"""
# hole das übergeordnete Ordner Objekt
parentdirobj = Folder.objects.get(id=parentdirid)
# Teste ob Ordnername in diesem Verzeichnis bereits existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(
directoryname, Folder, parentdirobj, request)
if not unique:
return failurereturn
# Versuche den Ordner in der Datenbank zu speichern
try:
newfolder = Folder(name=directoryname,
parent=parentdirobj,
root=parentdirobj.getRoot())
newfolder.save()
return util.jsonResponse(
{
'id': newfolder.id,
'name': newfolder.name,
'parentid': parentdirobj.id,
'parentname': parentdirobj.name
}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def inviteUser(request, user, projectid, inviteusermail):
"""Lädt einen anderen Benutzer zur Kollaboration an einem Projekt ein.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: ID des Projektes, zu dessen Zusammenarbeit eingeladen werden soll
:param inviteusermail: E-Mail-Adresse des Benutzers, welcher eingeladen werden soll
:return: HttpResponse (JSON)
"""
inviteusermail_lower = inviteusermail.lower()
# wenn sich die übergebene E-Mail-Adresse des einzuladenen Nutzers von der des aufrufenden Nutzers unterscheidet
if user.username.lower()!=inviteusermail_lower :
# wenn die übergebene E-Mail-Adresse registriert ist
if User.objects.filter(username__iexact=inviteusermail_lower).exists() :
# einzuladener Nutzer
inviteuser = User.objects.get(username__iexact=inviteusermail_lower)
# wenn noch keine entsprechende Kollaboration vorliegt
if not Collaboration.objects.filter(user=inviteuser.id,project=projectid).exists() :
# versucht eine entsprechende Kollaboration anzulegen
try:
Collaboration.objects.create(user=inviteuser, project=Project.objects.get(id=projectid))
return util.jsonResponse({}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
# wenn eine entsprechende Kollaboration bereits vorliegt
else :
return util.jsonErrorResponse(ERROR_MESSAGES['USERALREADYINVITED'] % inviteuser.username, request)
else :
return util.jsonErrorResponse(ERROR_MESSAGES['USERNOTFOUND'] % inviteusermail, request)
# wenn es sich bei der übergebenen E-Mail-Adresse des einzuladenen Nutzers um die des aufrufenden Nutzers handelt
else :
return util.jsonErrorResponse(ERROR_MESSAGES['USERALREADYINVITED'] % user.username, request)
def renameDir(request, user, folderid, newdirectoryname):
"""Benennt den Ordner mit der angegebenen Id um.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des Ordners, welcher umbenannt werden soll
:param newdirectoryname: neuer Name des Ordners
:return: HttpResponse (JSON)
"""
# hole das Ordner Objekt
folder = Folder.objects.get(id=folderid)
# Teste ob Ordnername in diesem Verzeichnis bereits existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(
newdirectoryname, Folder, folder.parent, request)
if not unique:
return failurereturn
# Versuche die Änderung in die Datenbank zu übernehmen
try:
folder.name = newdirectoryname
folder.save()
return util.jsonResponse({
'id': folder.id,
'name': folder.name
}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def renameDir(request, user, folderid, newdirectoryname):
"""Benennt den Ordner mit der angegebenen Id um.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des Ordners, welcher umbenannt werden soll
:param newdirectoryname: neuer Name des Ordners
:return: HttpResponse (JSON)
"""
# hole das Ordner Objekt
folder = Folder.objects.get(id=folderid)
# Teste ob Ordnername in diesem Verzeichnis bereits existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(newdirectoryname, Folder, folder.parent, request)
if not unique:
return failurereturn
# Versuche die Änderung in die Datenbank zu übernehmen
try:
folder.name = newdirectoryname
folder.save()
return util.jsonResponse({'id': folder.id, 'name': folder.name}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def createDir(request, user, parentdirid=0, directoryname=""):
"""Erstellt einen neuen Ordner im angegebenen Verzeichnis.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param parentdirid: Id des übergeordneten Ordners
:param directoryname: Name des zu erstellenden Ordners
:return: HttpResponse (JSON)
"""
# hole das übergeordnete Ordner Objekt
parentdirobj = Folder.objects.get(id=parentdirid)
# Teste ob Ordnername in diesem Verzeichnis bereits existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(directoryname, Folder, parentdirobj, request)
if not unique:
return failurereturn
# Versuche den Ordner in der Datenbank zu speichern
try:
newfolder = Folder(name=directoryname, parent=parentdirobj, root=parentdirobj.getRoot())
newfolder.save()
return util.jsonResponse({'id': newfolder.id, 'name': newfolder.name, 'parentid': parentdirobj.id,
'parentname': parentdirobj.name}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def uploadFiles(request, user, folderid):
"""Speichert vom Client gesendete Dateien im entsprechenden Projektordner.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des Ordners, in welchen die hochgeladenen Dateien gespeichert werden sollen.
:return: HttpResponse (JSON)
"""
# dictionary für die Rückgabe von erfolgreich gespeicherten Dateien bzw. fehlgeschlagenen
# es wird jeweils der name zurückgegeben (bei Erfolg zusätzlich die fileid, bei Fehlschlag der Grund)
errors = []
success = []
folder = Folder.objects.get(id=folderid)
# Teste ob auch Dateien gesendet wurden
if not request.FILES and not request.FILES.getlist('files'):
return util.jsonErrorResponse(ERROR_MESSAGES['NOTALLPOSTPARAMETERS'], request)
# Hole dateien aus dem request
files = request.FILES.getlist('files')
# Gehe die Dateien einzeln durch, bei Erfolg, setze id und name auf die success Liste
# Bei Fehler, setzte mit name und Grund auf die errors Liste
for f in files:
rsp, response = util.uploadFile(f, folder, request)
if not rsp:
errors.append({'name': f.name, 'reason': response})
else:
success.append(response)
return util.jsonResponse({'success': success, 'failure': errors}, True, request)
def moveDir(request, user, folderid, newfolderid):
"""Verschiebt den Ordner mit der angegebenen id in den neuen Ordner mit der newfolderid.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des Ordners, der verschoben werden soll
:param newfolderid: Id des Ordners, in welchen der Ordner mit der folderid verschoben werden soll
:return: HttpResponse (JSON)
"""
# hole die beiden Ordner Objekte
folderobj = Folder.objects.get(id=folderid)
newparentfolderobj = Folder.objects.get(id=newfolderid)
# Teste ob Ordnername in diesem Verzeichnis bereits existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(folderobj.name, Folder, newparentfolderobj, request)
# Man darf ein Verzeichnis in dieselbes Verzeichnis verschieben (dann passiert einfach nichts)
if not unique and folderobj.parent != newparentfolderobj:
return failurereturn
# Versuche die Änderung in die Datenbank zu übernehmen
try:
# setze den newfolder als neues übergeordnetes Verzeichnis
folderobj.parent = newparentfolderobj
# dessen root Verzeichnis wird auch das Rootverzeichnis vom folderobj (verschieben zwischen Projekten)
folderobj.root = newparentfolderobj.getRoot()
folderobj.save()
return util.jsonResponse({'id': folderobj.id,
'name': folderobj.name,
'parentid': folderobj.parent.id,
'parentname': folderobj.parent.name,
'rootid': folderobj.root.id},
True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def updateFile(request, user, fileid, filecontenttostring):
"""Aktualisiert eine geänderte Datei eines Projektes in der Datenbank (akzeptiert nur PlainTextFiles).
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der Datei, welche geändert werden soll
:param filecontenttostring: neuer Dateiinhalt als String
:return: HttpResponse (JSON)
"""
# lese die PlainTextFile Datei ein
plaintextobj = PlainTextFile.objects.get(id=fileid)
isallowedit = not plaintextobj.isLocked() or plaintextobj.lockedBy() == user
# wenn die Datei vom aktuellen Benutzer nicht bearbeitet werden darf (gesperrt bzw. nicht selber gesperrt)
if not isallowedit:
# speichere den Inhalt als neue Datei mit dem aktuellen Datum als Suffix
newplaintextobj_name = plaintextobj.name + '_' + user.username + '_' \
+ util.datetimeToString(datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
if not PlainTextFile.objects.filter(name=newplaintextobj_name, folder=plaintextobj.folder).exists():
newplaintextobj = TexFile.objects.create(name=newplaintextobj_name, folder=plaintextobj.folder,
source_code=filecontenttostring)
lasteditor = ""
if plaintextobj.lasteditor:
plaintextobj.lasteditor.username
return util.jsonResponse({'id': newplaintextobj.id, 'name': newplaintextobj.name,
'lasteditor': lasteditor},
True, request)
return util.jsonErrorResponse(ERROR_MESSAGES['FILELOCKED'])
# sonst sperre die Datei
plaintextobj.lock(user)
# versuche den source code in der Datenbank durch den übergebenen String zu ersetzen
try:
plaintextobj.source_code = filecontenttostring
plaintextobj.lasteditor = user
plaintextobj.save()
return util.jsonResponse({'id': plaintextobj.id, 'name': plaintextobj.name}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def cancelCollaboration(request, user, projectid, collaboratoremail):
"""Entzieht der Freigabe
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: ID des Projektes, zu dessen der Freigabe entzieht werden soll
:param collaboratoremail: E-Mail-Adresse der Kollaborateur
:return: HttpResponse (JSON)
"""
try:
project = Project.objects.get(pk=projectid)
collaborator = User.objects.get(username=collaboratoremail)
if user == collaborator:
return util.jsonErrorResponse(ERROR_MESSAGES['SELFCOLLABORATIONCANCEL'], request)
collaboration = Collaboration.objects.get(user=collaborator, project=project)
collaboration.delete()
except ObjectDoesNotExist:
return util.jsonErrorResponse(ERROR_MESSAGES['COLLABORATIONNOTFOUND'], request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
if not collaboration.isConfirmed:
return util.jsonResponse({}, True, request)
# ermittelt einen noch nicht verwendeten Projektnamen anhand des übergebenen Namens
validname = util.getNextValidProjectName(collaborator,project.name+' ['+user.username+']')
# versucht ein Duplikat des Projektes für den Kollaborateur in der Datenbank zu erstellen
try:
Project.objects.cloneProject(project=project, name=validname, author=collaborator)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
return util.jsonResponse({}, True, request)
def unlockFile(request, user, fileid):
"""Entsperrt die Datei.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der Datei welche entsperrt werden soll
:return: HttpResponse (JSON)
"""
file = File.objects.get(pk=fileid)
if file.isLocked() and file.lockedBy() != user:
return util.jsonErrorResponse(ERROR_MESSAGES['UNLOCKERROR'], request)
file.unlock()
return util.jsonResponse({}, True, request)
def listFiles(request, user, folderid):
"""Liefert eine Übersicht der Dateien/Unterordner eines Ordners (bzw. Projektes).
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des Ordners, von dem die enthaltenen Dateien und Unterordner aufgelistet werden sollen
:return: HttpResponse (JSON)
"""
# hole das Ordner Objekt
current_folderobj = Folder.objects.get(id=folderid)
# erstelle die Ordner- und Dateistruktur als JSON
folderandfiles_structure = util.getFolderAndFileStructureAsDict(current_folderobj, user)
return util.jsonResponse(folderandfiles_structure, True, request)
def hasInvitedUsers(request, user, projectid):
"""Gibt an, ob für das, der übergebenen Projekt-ID entsprechende, Projekt eingeladene Nutzer vorliegen.
Hierbei ist es unerheblich, ob die jeweilige Einladung bereits bestätigt wurde.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: ID des Projektes, von dessen eingeladenen Benutzern die Nutzernamen zurückgegeben werden sollen
:return: HttpResponse (JSON)
"""
collaborations = Collaboration.objects.filter(project=Project.objects.get(id=projectid))
if collaborations is None:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
else:
return util.jsonResponse(collaborations.exists(), True, request)
def listTemplates(request, user):
"""Liefert eine Übersicht aller Vorlagen eines Benutzers.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:return: HttpResponse (JSON)
"""
availableprojects = ProjectTemplate.objects.filter(author=user, project__isnull=True)
if availableprojects is None:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
else:
json_return = [util.projectToJson(template)
for template in availableprojects]
return util.jsonResponse(json_return, True, request)
def listUnconfirmedCollaborativeProjects(request, user):
"""Liefert eine Liste aller Projekte, zu deren Kollaboration der übergebene Benutzer eingeladen ist, diese jedoch noch nicht bestätigt hat.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:return: HttpResponse (JSON)
"""
unconfirmedCollaborations = Collaboration.objects.filter(user=user,isConfirmed=False)
if unconfirmedCollaborations is None:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
else:
json_return = [util.projectToJson(collaboration.project)
for collaboration in unconfirmedCollaborations]
return util.jsonResponse(json_return, True, request)
def listFiles(request, user, folderid):
"""Liefert eine Übersicht der Dateien/Unterordner eines Ordners (bzw. Projektes).
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des Ordners, von dem die enthaltenen Dateien und Unterordner aufgelistet werden sollen
:return: HttpResponse (JSON)
"""
# hole das Ordner Objekt
current_folderobj = Folder.objects.get(id=folderid)
# erstelle die Ordner- und Dateistruktur als JSON
folderandfiles_structure = util.getFolderAndFileStructureAsDict(
current_folderobj, user)
return util.jsonResponse(folderandfiles_structure, True, request)
def templateRm(request, user, templateid):
"""Löscht eine vorhandene Vorlage.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param templateid: Id der Vorlage welche gelöscht werden soll
:return: HttpResponse (JSON)
"""
# hole die zu löschende Vorlage
templateobj = ProjectTemplate.objects.get(id=templateid)
# versuche die Vorlage zu löschen
try:
templateobj.delete()
return util.jsonResponse({}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def projectRm(request, user, projectid):
"""Löscht ein vorhandenes Projekt eines Benutzers.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: Id des Projektes welches gelöscht werden soll
:return: HttpResponse (JSON)
"""
# hole das zu löschende Projekt
projectobj = Project.objects.get(id=projectid)
# versuche das Projekt zu löschen
try:
projectobj.delete()
return util.jsonResponse({}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def deleteFile(request, user, fileid):
"""Löscht eine vom Client angegebene Datei eines Projektes.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der Datei welche gelöscht werden soll
:return: HttpResponse (JSON)
"""
# hole das file object
fileobj = File.objects.get(id=fileid)
# versuche die Datei zu löschen
try:
fileobj.delete()
return util.jsonResponse({}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def listInvitedUsers(request, user, projectid):
"""Liefert eine Liste der Nutzernamen aller Nutzer, welche für das, der übergebenen Projekt-ID entsprechende, Projekt eingeladen sind.
Hierbei ist es unerheblich, ob die jeweilige Einladung bereits bestätigt wurde.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: ID des Projektes, von dessen eingeladenen Benutzern die Nutzernamen zurückgegeben werden sollen
:return: HttpResponse (JSON)
"""
collaborations = Collaboration.objects.filter(project=Project.objects.get(id=projectid)).order_by('user__username')
if collaborations is None:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
else:
json_return = [collaboration.user.username
for collaboration in collaborations]
return util.jsonResponse(json_return, True, request)
def template2Project(request, user, templateid, projectname):
"""Wandelt eine Vorlage in ein Projekt um.
Hierbei wird der übergebene Projektname für das zu erzeugende Projekt ggf. mit einem generierten numerischen Suffix versehen,
sofern dieser Name bereits für ein Projekt des betroffenen Benutzers verwendet wird.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param templateid: Id der Vorlage, welche umgewandelt werden soll
:param projectname: Name des zu erstellenden Projektes
:return: HttpResponse (JSON)
"""
# ermittelt einen noch nicht verwendeten Projektnamen anhand des übergebenen Namens
validname = util.getNextValidProjectName(user,projectname)
# Erstelle Projekt aus der Vorlage
template = ProjectTemplate.objects.get(id=templateid)
project = Project.objects.createFromProjectTemplate(template=template, name=validname)
return util.jsonResponse({'id': project.id, 'name': project.name, 'rootid': project.rootFolder.id}, True, request)
def project2Template(request, user, projectid, templatename):
"""Wandelt ein Projekt in eine Vorlage um.
Hierbei wird der übergebene Vorlagenname für die zu erzeugende Vorlage ggf. mit einem generierten numerischen Suffix versehen,
sofern dieser Name bereits für eine Vorlage des betroffenen Benutzers verwendet wird.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: Id des Projektes, welches umgewandelt werden soll
:param templatename: Name der zu erstellenden Vorlage
:return: HttpResponse (JSON)
"""
# ermittelt einen noch nicht verwendeten Vorlagennamen anhand des übergebenen Namens
validname = util.getNextValidTemplateName(user,templatename)
# Erstelle template aus dem Project
project = Project.objects.get(id=projectid)
template = ProjectTemplate.objects.createFromProject(project=project, name=validname, author=user)
return util.jsonResponse({'id': template.id, 'name': template.name}, True, request)
def fileInfo(request, user, fileid):
"""Liefert Informationen zur angeforderten Datei.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der Datei, von der die Informationen angefordert werden
:return: HttpResponse (JSON)
"""
# hole das Datei und Ordner Objekt
fileobj = File.objects.get(id=fileid)
folderobj = Folder.objects.get(id=fileobj.folder.id)
# ermittelt das Projekt der Datei
projectobj = folderobj.getProject()
# Sende die Datei-Informationen als JSON response
isallowedit = not fileobj.isLocked() or fileobj.lockedBy() == user
lasteditor = ""
if fileobj.lasteditor:
lasteditor = fileobj.lasteditor.username
# Sende die id und den Namen der Datei sowie des Ordners als JSON response
dictionary = {'fileid': fileobj.id,
'filename': fileobj.name,
'folderid': folderobj.id,
'foldername': folderobj.name,
'projectid': projectobj.id,
'projectname': projectobj.name,
'createtime': util.datetimeToString(fileobj.createTime),
'lastmodifiedtime': util.datetimeToString(fileobj.lastModifiedTime),
'size': fileobj.size,
'isallowedit': isallowedit,
'lasteditor': lasteditor,
'mimetype': fileobj.mimeType,
'ownerid': projectobj.author.id,
'ownername': projectobj.author.username
}
return util.jsonResponse(dictionary, True, request)
def quitCollaboration(request, user, projectid):
"""Kündigt der Kollaboration (bzw. Einladung) an einem Projekt (als Kollaborateur)
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: ID des Projektes, zu dessen die Kollaboration (bzw. die Einladung) gekündigt werden soll
:return: HttpResponse (JSON)
"""
try:
project = Project.objects.get(pk=projectid)
if user == project.author:
return util.jsonErrorResponse(ERROR_MESSAGES['SELFCOLLABORATIONCANCEL'], request)
collaboration = Collaboration.objects.get(user=user, project=project)
collaboration.delete()
return util.jsonResponse({}, True, request)
except ObjectDoesNotExist:
return util.jsonErrorResponse(ERROR_MESSAGES['COLLABORATIONNOTFOUND'], request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def listProjects(request, user):
"""Liefert eine Übersicht aller Projekte eines Benutzers
(einschließlich seiner kollaborativen Projekte).
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:return: HttpResponse (JSON)
"""
userprojects = Project.objects.filter(author=user)
collaborations = Collaboration.objects.filter(user=user,isConfirmed=True)
if userprojects is None or collaborations is None:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
else:
json_return = [util.projectToJson(project)
for project in userprojects]
json_return += [util.projectToJson(collaboration.project)
for collaboration in collaborations]
return util.jsonResponse(json_return, True, request)
def rmDir(request, user, folderid):
"""Löscht den Ordner mit der angegebenen Id.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des zu löschenden Ordners
:return: HttpResponse (JSON)
"""
# hole das Ordner Objekt
folderobj = Folder.objects.get(id=folderid)
# überprüfe, ob der Ordner ein Rootfolder eines Projektes ist, diese dürfen nicht gelöscht werden
if folderobj.isRoot():
return util.jsonErrorResponse(ERROR_MESSAGES['NOTENOUGHRIGHTS'], request)
# versuche das Ordner Objekt zu löschen
try:
folderobj.delete()
return util.jsonResponse({}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def getLog(request, user, fileid):
"""Liefert die Log Datei vom Kompilieren einer Tex Datei.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der tex Datei, von welcher die PDF Datei angefordert wurde
:return: HttpResponse (JSON)
"""
# hole das tex Objekt
texobj = TexFile.objects.get(id=fileid)
logfilename = texobj.name[:-3] + '<log>'
logobj = PlainTextFile.objects.filter(name=logfilename, folder=texobj.folder)
if logobj.exists:
log = logobj[0].source_code
else:
log = ERROR_MESSAGES['NOLOGFILE']
return util.jsonResponse({'log': log}, True, request)
def moveDir(request, user, folderid, newfolderid):
"""Verschiebt den Ordner mit der angegebenen id in den neuen Ordner mit der newfolderid.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des Ordners, der verschoben werden soll
:param newfolderid: Id des Ordners, in welchen der Ordner mit der folderid verschoben werden soll
:return: HttpResponse (JSON)
"""
# hole die beiden Ordner Objekte
folderobj = Folder.objects.get(id=folderid)
newparentfolderobj = Folder.objects.get(id=newfolderid)
# Teste ob Ordnername in diesem Verzeichnis bereits existiert
unique, failurereturn = util.checkIfFileOrFolderIsUnique(
folderobj.name, Folder, newparentfolderobj, request)
# Man darf ein Verzeichnis in dieselbes Verzeichnis verschieben (dann passiert einfach nichts)
if not unique and folderobj.parent != newparentfolderobj:
return failurereturn
# Versuche die Änderung in die Datenbank zu übernehmen
try:
# setze den newfolder als neues übergeordnetes Verzeichnis
folderobj.parent = newparentfolderobj
# dessen root Verzeichnis wird auch das Rootverzeichnis vom folderobj (verschieben zwischen Projekten)
folderobj.root = newparentfolderobj.getRoot()
folderobj.save()
return util.jsonResponse(
{
'id': folderobj.id,
'name': folderobj.name,
'parentid': folderobj.parent.id,
'parentname': folderobj.parent.name,
'rootid': folderobj.root.id
}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def projectRename(request, user, projectid, newprojectname):
"""Benennt ein Projekt um.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: Id des Projektes welches umbenannt werden soll
:param newprojectname: neuer Name des Projektes
:return: HttpResponse (JSON)
"""
# hole das Projekt, welches umbenannt werden soll
projectobj = Project.objects.get(id=projectid)
# überprüfe ob ein Projekt mit dem Namen 'projectname' bereits für diese Benutzer existiert
if Project.objects.filter(name__iexact=newprojectname.lower(), author=user).exists():
return util.jsonErrorResponse(ERROR_MESSAGES['PROJECTALREADYEXISTS'] % newprojectname, request)
else:
# versuche das Projekt umzubenennen
try:
projectobj.name = newprojectname
projectobj.save()
return util.jsonResponse({'id': projectobj.id, 'name': projectobj.name}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def latexCompile(request, user, fileid, formatid, forcecompile):
"""Kompiliert eine LaTeX Datei.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param fileid: Id der tex Datei welche kompiliert werden soll
:param formatid 0 - PDF, 1 - HTML
:return: HttpResponse (JSON)
"""
errors, success = latexcompile(fileid, formatid=formatid, forcecompile=forcecompile)
if errors:
if success:
ret = success
else:
ret = dict()
ret['error'] = json.dumps(errors)
return util.jsonErrorResponse(ret, request)
if success:
return util.jsonResponse(success, True, request)
# Sonst Fehlermeldung an Client
return util.jsonErrorResponse(ERROR_MESSAGES['COMPILATIONERROR'], request)
def projectCreate(request, user, projectname):
"""Erstellt ein neues Projekt mit dem Namen projectname (ggf. mit einem generierten numerischen Suffix).
Es wird ein neues Projekt in der Datenbank angelegt.
Durch das Projektmodell wird automatisch eine leere main.tex Datei im Hauptverzeichnis erstellt.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectname: Name des neuen Projektes
:return: HttpResponse (JSON)
"""
# ermittelt einen noch nicht verwendeten Projektnamen anhand des übergebenen Namens
validname = util.getNextValidProjectName(user,projectname)
# versucht das Projekt in der Datenbank zu erstellen
try:
newproject = Project.objects.createWithMainTex(author=user, name=validname)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
# gibt die Id und den Namen des erstellten Projektes zurück
return util.jsonResponse({'id': newproject.id, 'name': newproject.name}, True, request)
def rmDir(request, user, folderid):
"""Löscht den Ordner mit der angegebenen Id.
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param folderid: Id des zu löschenden Ordners
:return: HttpResponse (JSON)
"""
# hole das Ordner Objekt
folderobj = Folder.objects.get(id=folderid)
# überprüfe, ob der Ordner ein Rootfolder eines Projektes ist, diese dürfen nicht gelöscht werden
if folderobj.isRoot():
return util.jsonErrorResponse(ERROR_MESSAGES['NOTENOUGHRIGHTS'],
request)
# versuche das Ordner Objekt zu löschen
try:
folderobj.delete()
return util.jsonResponse({}, True, request)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
def projectClone(request, user, projectid, newprojectname):
"""Erstellt eine Kopie eines Projektes mit dem Namen newprojectname (ggf. mit einem generierten numerischen Suffix).
:param request: Anfrage des Clients, wird unverändert zurückgesendet
:param user: User Objekt (eingeloggter Benutzer)
:param projectid: Id des Projektes, welches geklont werden soll
:param newprojectname: Name des neuen Projektes
:return: HttpResponse (JSON)
"""
# ermittelt einen noch nicht verwendeten Projektnamen anhand des übergebenen Namens
validname = util.getNextValidProjectName(user,newprojectname)
# holt des aktuelle Projekt-Objekt
projectobj = Project.objects.get(id=projectid)
# versucht das Projekt in der Datenbank zu erstellen
try:
newproject = Project.objects.cloneProject(project=projectobj, name=validname, author=user)
except:
return util.jsonErrorResponse(ERROR_MESSAGES['DATABASEERROR'], request)
# gibt die Id und den Namen des erstellte Projektes zurück
return util.jsonResponse({'id': newproject.id, 'name': newproject.name}, True, request)
