@Override
public Long getUserAvailableSize(UserVo userVo) throws BusinessException {
Account account = accountService.findByLsUuid(userVo.getLsUuid());
return Math.min(
documentEntryService.getAvailableSize(account),
documentEntryService.getUserMaxFileSize(account));
}
@Override
public MimeTypeStatus getMimeTypeStatus(String login, String uuid) {
Account actor = accountService.findByLsUuid(login);
if (actor != null) {
DocumentEntry entry;
try {
entry = documentEntryService.findById(actor, uuid);
return documentEntryService.getDocumentMimeTypeStatus(entry);
} catch (BusinessException e) {
logger.error("can't get document : " + e.getMessage());
}
}
return null;
}
@Override
public void renameFile(String userlogin, String docEntryUuid, String newName) {
Account actor = accountService.findByLsUuid(userlogin);
try {
documentEntryService.renameDocumentEntry(actor, docEntryUuid, newName);
} catch (BusinessException e) {
logger.error("Can't rename document : " + docEntryUuid + " : " + e.getMessage());
}
}
private DisplayableAccountOccupationEntryVo getAccountStats(User user) throws BusinessException {
Long userAvailableQuota = documentEntryService.getAvailableSize(user);
Long userTotalQuota = documentEntryService.getTotalSize(user);
Long userUsedSize = 0L;
for (Entry entry : user.getEntries()) {
if (entry.getEntryType().equals(EntryType.DOCUMENT)) {
userUsedSize += ((DocumentEntry) entry).getSize();
}
}
DisplayableAccountOccupationEntryVo accountOccupation =
new DisplayableAccountOccupationEntryVo(
user.getFirstName(),
user.getLastName(),
user.getMail(),
user.getAccountType(),
userAvailableQuota,
userTotalQuota,
userUsedSize);
return accountOccupation;
}
@Override
public DocumentVo insertFile(InputStream in, String fileName, UserVo owner)
throws BusinessException {
logger.debug("insert files for document entries");
Account actor = accountService.findByLsUuid(owner.getLsUuid());
fileName = fileName.replace("\\", "_");
fileName = fileName.replace(":", "_");
DocumentEntry createDocumentEntry =
documentEntryService.createDocumentEntry(actor, in, fileName);
return documentEntryTransformer.disassemble(createDocumentEntry);
}
@Override
public List<SignatureVo> getAllSignatures(UserVo userVo, DocumentVo documentVo) {
Account actor = accountService.findByLsUuid(userVo.getLsUuid());
try {
DocumentEntry document = documentEntryService.findById(actor, documentVo.getIdentifier());
return signatureTransformer.disassembleList(
new ArrayList<Signature>(document.getDocument().getSignatures()));
} catch (BusinessException e) {
logger.error("Can't find document : " + documentVo.getIdentifier() + ": " + e.getMessage());
}
return null;
}
@Override
public boolean isSignedDocument(String userLsUuid, DocumentVo documentVo) {
// Fix me : just write a finder
boolean res = false;
Account actor = accountService.findByLsUuid(userLsUuid);
try {
DocumentEntry document = documentEntryService.findById(actor, documentVo.getIdentifier());
Set<Signature> signatures = document.getDocument().getSignatures();
if (signatures != null && signatures.size() > 0) res = true;
} catch (BusinessException e) {
logger.error("Can't find document : " + documentVo.getIdentifier() + ": " + e.getMessage());
}
return res;
}
@Override
public void insertSignatureFile(
InputStream file,
long size,
String fileName,
UserVo ownerVo,
DocumentVo documentVo,
X509Certificate signerCertificate)
throws BusinessException {
Account actor = accountService.findByLsUuid(ownerVo.getLsUuid());
DocumentEntry documentEntry = documentEntryService.findById(actor, documentVo.getIdentifier());
signatureService.createSignature(
actor, documentEntry.getDocument(), file, size, fileName, signerCertificate);
}
@Override
public DocumentVo updateDocumentContent(
String currentFileUUID,
InputStream file,
long size,
String fileName,
UserVo ownerVo,
String friendlySize)
throws BusinessException {
Account actor = accountService.findByLsUuid(ownerVo.getLsUuid());
DocumentEntry originalEntry = documentEntryService.findById(actor, currentFileUUID);
String originalFileName = originalEntry.getName();
DocumentEntry documentEntry =
documentEntryService.updateDocumentEntry(actor, currentFileUUID, file, size, fileName);
if (documentEntry.isShared()) {
// send email, file has been replaced ....
entryService.sendSharedUpdateDocNotification(documentEntry, friendlySize, originalFileName);
}
return documentEntryTransformer.disassemble(documentEntry);
}
@Override
public void updateFileProperties(
String userlogin, String docEntryUuid, String newName, String comment) {
Account actor = accountService.findByLsUuid(userlogin);
if (comment == null) {
comment = "";
}
try {
documentEntryService.updateFileProperties(actor, docEntryUuid, newName, comment);
} catch (BusinessException e) {
logger.error(
"Can't update file properties document : " + docEntryUuid + " : " + e.getMessage());
}
}
@Override
public boolean documentHasThumbnail(String actorUuid, String docEntryUuid) {
if (actorUuid == null) {
logger.error("Can't find user with null parameter.");
return false;
}
Account actor = accountService.findByLsUuid(actorUuid);
if (actor == null) {
logger.error("Can't find logged user.");
return false;
}
return documentEntryService.documentHasThumbnail(actor, docEntryUuid);
}
@Override
public DocumentVo getDocument(String login, String uuid) {
Account actor = accountService.findByLsUuid(login);
if (actor != null) {
DocumentEntry entry;
try {
entry = documentEntryService.findById(actor, uuid);
return documentEntryTransformer.disassemble(entry);
} catch (BusinessException e) {
logger.error("can't get document : " + e.getMessage());
}
}
return null;
}
@Override
public void deleteUploadRequestEntry(
String uploadRequestUrlUuid, String password, String entryUuid) throws BusinessException {
UploadRequestUrl requestUrl = find(uploadRequestUrlUuid, password);
deleteBusinessCheck(requestUrl);
Set<UploadRequestEntry> entries = requestUrl.getUploadRequest().getUploadRequestEntries();
UploadRequestEntry found = null;
for (UploadRequestEntry entry : entries) {
if (entry.getUuid().equals(entryUuid)) {
found = entry;
break;
}
}
if (found != null) {
String documentEntryUuid = null;
if (found.getDocumentEntry() != null) {
documentEntryUuid = found.getDocumentEntry().getUuid();
}
found.setDocumentEntry(null);
found = uploadRequestEntryBusinessService.update(found);
if (documentEntryUuid != null) {
// TODO: HOOK : Extract owner for upload request URL
// Actor should be used instead of owner
Account owner = requestUrl.getUploadRequest().getOwner();
// Store the file into the owner account.
DocumentEntry documentEntry = documentEntryService.findById(owner, documentEntryUuid);
documentEntryService.deleteDocumentEntry(owner, documentEntry);
}
uploadRequestEntryBusinessService.delete(found);
} else {
throw new BusinessException(
BusinessErrorCode.FORBIDDEN,
"You do not have the right to delete a file into upload request : "
+ uploadRequestUrlUuid);
}
}
@Override
public SignatureVo getSignature(UserVo currentSigner, DocumentVo documentVo) {
Account actor = accountService.findByLsUuid(currentSigner.getLsUuid());
try {
DocumentEntry document = documentEntryService.findById(actor, documentVo.getIdentifier());
SignatureVo res = null;
for (Signature signature : document.getDocument().getSignatures()) {
if (signature.getSigner().equals(actor)) {
res = signatureTransformer.disassemble(signature);
break;
}
}
return res;
} catch (BusinessException e) {
logger.error("Can't find document : " + documentVo.getIdentifier() + ": " + e.getMessage());
}
return null;
}
@Override
public boolean isSignedDocumentByCurrentUser(UserVo currentSigner, DocumentVo documentVo)
throws BusinessException {
Account actor = accountService.findByLsUuid(currentSigner.getLsUuid());
DocumentEntry doc = documentEntryService.findById(actor, documentVo.getIdentifier());
Set<Signature> signatures = doc.getDocument().getSignatures();
boolean res = false;
for (Signature signature : signatures) {
if (signature.getSigner().equals(actor)) {
res = true;
break;
}
}
return res;
}
@Override
public InputStream getDocumentThumbnail(String actorUuid, String docEntryUuid) {
if (actorUuid == null) {
logger.error("Can't find user with null parameter.");
return null;
}
Account actor = accountService.findByLsUuid(actorUuid);
if (actor == null) {
logger.error("Can't find logged user.");
return null;
}
try {
return documentEntryService.getDocumentThumbnailStream(actor, docEntryUuid);
} catch (BusinessException e) {
logger.error("Can't get document thumbnail : " + docEntryUuid + " : " + e.getMessage());
}
return null;
}
@Override
public UploadRequestEntry createUploadRequestEntry(
String uploadRequestUrlUuid, InputStream fi, String fileName, String password)
throws BusinessException {
// Retrieve upload request URL
UploadRequestUrl requestUrl = find(uploadRequestUrlUuid, password);
// HOOK : Extract owner for upload request URL
Account owner = requestUrl.getUploadRequest().getOwner();
// Store the file into the owner account.
DocumentEntry document = documentEntryService.createDocumentEntry(owner, fi, fileName);
createBusinessCheck(requestUrl, document);
Account actor = accountRepository.getUploadRequestSystemAccount();
// Create the link between the document and the upload request URL.
UploadRequestEntry uploadRequestEntry =
new UploadRequestEntry(document, requestUrl.getUploadRequest());
UploadRequestEntry requestEntry = uploadRequestEntryBusinessService.create(uploadRequestEntry);
MailContainerWithRecipient mail =
mailBuildingService.buildAckUploadRequest(
(User) requestUrl.getUploadRequest().getOwner(), requestUrl, requestEntry);
notifierService.sendNotification(mail);
return requestEntry;
}
@Override
public InputStream retrieveFileStream(DocumentVo doc, String lsUid) throws BusinessException {
Account actor = accountService.findByLsUuid(lsUid);
return documentEntryService.getDocumentStream(actor, doc.getIdentifier());
}
@Override
public Long getGlobalQuota(UserVo userVo) throws BusinessException {
Account actor = accountService.findByLsUuid(userVo.getLsUuid());
return documentEntryService.getGlobalQuota(actor);
}
@Override
public boolean isUserQuotaActive(UserVo userVo) throws BusinessException {
Account actor = accountService.findByLsUuid(userVo.getLsUuid());
return documentEntryService.isUserQuotaActive(actor);
}
@Override
public boolean isEnciphermentActive(UserVo userVo) {
Account actor = accountService.findByLsUuid(userVo.getLsUuid());
return documentEntryService.isEnciphermentActive(actor);
}
@Override
public Long getUserTotalQuota(UserVo userVo) throws BusinessException {
Account account = accountService.findByLsUuid(userVo.getLsUuid());
return documentEntryService.getTotalSize(account);
}