Files
ofbiz-framework/applications/content/groovyScripts/data/DataServices.groovy
T

389 lines
14 KiB
Groovy

import java.sql.Timestamp
import org.apache.ofbiz.base.util.UtilDateTime
import org.apache.ofbiz.base.util.UtilProperties
import org.apache.ofbiz.content.data.DataResourceWorker
import org.apache.ofbiz.entity.GenericValue
import org.apache.ofbiz.entity.util.EntityUtil
import org.apache.ofbiz.service.ModelService
import org.apache.ofbiz.service.ServiceUtil
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
//Methods for DataResource
/**
* Create a Data Resource
*
* @return
*/
def createDataResource() {
Map result = success()
GenericValue newEntity = makeValue("DataResource", parameters)
if (!newEntity.dataResourceId) {
newEntity.dataResourceId = delegator.getNextSeqId("DataResource")
}
Timestamp nowTimestamp = UtilDateTime.nowTimestamp()
GenericValue userLogin = parameters.userLogin
newEntity.lastModifiedByUserLogin = userLogin.userLoginId
newEntity.createdByUserLogin = userLogin.userLoginId
newEntity.lastModifiedDate = nowTimestamp
newEntity.createdDate = nowTimestamp
if (!parameters.dataTemplateTypeId) {
newEntity.dataTemplateTypeId = "NONE"
}
if (!parameters.statusId) {
//get first status item
GenericValue statusItem = from("StatusItem")
.where("statusTypeId", "CONTENT_STATUS")
.orderBy("sequenceId")
.queryFirst()
newEntity.statusId = statusItem.statusId
}
if (!newEntity.mimeTypeId && parameters.uploadedFile) {
newEntity.mimeTypeId = DataResourceWorker.getMimeTypeWithByteBuffer(parameters.uploadedFile)
}
newEntity.create()
result.dataResourceId = newEntity.dataResourceId
result.dataResource = newEntity
return result
}
/**
* Create a Data Resource and return the data resource type
*
* @return
*/
def createDataResourceAndAssocToContent() {
GenericValue content = from("Content").where(parameters).queryOne()
if (!content) {
return error(UtilProperties.getMessage("ContentErrorUiLabels", "layoutEvents.content_empty", parameters.locale))
}
Map serviceResult = run service: "createDataResource", with: parameters
if (!ServiceUtil.isSuccess(serviceResult)) {
return serviceResult
}
GenericValue dataResource = serviceResult.dataResource
Map contentCtx = [:]
if (parameters.templateDataResource && parameters.templateDataResource == "Y") {
contentCtx.put("templateDataResourceId", parameters.dataResourceId)
} else {
contentCtx.put("dataRessourceId", parameters.dataResourceId)
}
contentCtx.put("contentId", parameters.contentId)
Map result = run service: "updateContent", with: contentCtx
if (!ServiceUtil.isSuccess(result)) {
return result
}
result.contentId = parameters.contentId
if (dataResource.dataResourceTypeId &&
(dataResource.dataResourceTypeId == "ELECTRONIC_TEXT" ||
dataResource.dataResourceTypeId == "IMAGE_OBJECT")) {
result.put(ModelService.RESPONSE_MESSAGE, "${dataResource.dataResourceTypeId}")
}
return result
}
/**
* Get Electronic Text
* @return
*/
def getElectronicText() {
Map result = success()
GenericValue userLogin = parameters.userLogin
GenericValue currentContent = parameters.content
logInfo("GETELECTRONICTEXT, currentContent:${currentContent}")
if (!currentContent) {
if (parameters.contentId) {
currentContent = from("Content").where(parameters).queryOne()
}
if (!currentContent) {
return error(UtilProperties.getMessage("ContentUiLabels", "ContentNeitherContentSupplied", parameters.locale))
}
}
if (!currentContent.dataResourceId) {
return error(UtilProperties.getMessage("ContentUiLabels", "ContentDataResourceNotFound", parameters.locale))
}
result.dataResourceId = currentContent.dataResourceId
GenericValue eText = from("ElectronicText").where("dataResourceId", currentContent.dataResourceId).queryOne()
if (!eText) {
return error(UtilProperties.getMessage("ContentUiLabels", "ContentElectronicTextNotFound", parameters.locale))
}
result.textData = eText.textData
return result
}
/**
* Attach an uploaded file to a data resource
*
* @return
*/
def attachUploadToDataResource() {
boolean isUpdate = false
boolean forceLocal = UtilProperties.getPropertyValue("content.properties", "content.upload.always.local.file")
List validLocalFileTypes = [
"LOCAL_FILE",
"OFBIZ_FILE",
"CONTEXT_FILE",
"LOCAL_FILE_BIN",
"OFBIZ_FILE_BIN",
"CONTEXT_FILE_BIN"
]
boolean isValidLocalType = parameters.dataResourceTypeId in validLocalFileTypes
if (forceLocal && !isValidLocalType) {
parameters.dataResourceTypeId = "LOCAL_FILE"
}
if (!parameters.dataResourceTypeId) {
// create default behaviour
if (parameters._uploadedFile_contentType) {
switch (parameters._uploadedFile_contentType) {
case ~/image.*/:
parameters.dataResourceTypeId = "IMAGE_OBJECT"
break
case ~/video.*/:
parameters.dataResourceTypeId = "VIDEO_OBJECT"
break
case ~/audio.*/:
parameters.dataResourceTypeId = "AUDIO_OBJECT"
break
default:
parameters.dataResourceTypeId = "OTHER_OBJECT"
}
} else {
parameters.dataResourceTypeId = "OTHER_OBJECT"
}
}
switch (parameters.dataResourceTypeId) {
case ["LOCAL_FILE", "LOCAL_FILE_BIN", "OFBIZ_FILE", "OFBIZ_FILE_BIN", "CONTEXT_FILE", "CONTEXT_FILE_BIN"]:
return saveLocalFileDataResource(parameters.dataResourceTypeId)
case "IMAGE_OBJECT":
GenericValue dataResObj = from("ImageDataResource")
.where("dataResourceId", parameters.dataResourceId)
.queryOne()
if (dataResObj) {
isUpdate = true
}
break
case "VIDEO_OBJECT":
GenericValue dataResObj = from("VideoDataResource")
.where("dataResourceId", parameters.dataResourceId)
.queryOne()
if (dataResObj) {
isUpdate = true
}
break
case "AUDIO_OBJECT":
GenericValue dataResObj = from("AudioDataResource")
.where("dataResourceId", parameters.dataResourceId)
.queryOne()
if (dataResObj) {
isUpdate = true
}
break
case "OTHER_OBJECT":
GenericValue dataResObj = from("OtherDataResource")
.where("dataResourceId", parameters.dataResourceId)
.queryOne()
if (dataResObj) {
isUpdate = true
}
break
}
return saveExtFileDataResource(isUpdate, parameters.dataResourceTypeId)
}
/**
* Attach an uploaded file to a data resource as a Local File-Type (Local, OfBiz or Context)
*
* @param absolute
* @return
*/
def saveLocalFileDataResource(String mode) {
Map result = success()
List errorList = []
boolean isUpdate = false
GenericValue dataResource = from("DataResource").where(parameters).queryOne()
if (!dataResource) {
errorList.add(UtilProperties.getMessage("ContentUiLabels", "ContentDataResourceNotFound", parameters.locale))
} else {
if (dataResource.objectInfo) {
isUpdate = true
}
}
if (!parameters._uploadedFile_fileName) {
if (isUpdate) {
// upload is found on an update; its okay, don't do anything just return
result.dataResourceId = dataResource.dataResourceId
result.mimeTypeId = dataResource.mimeTypeId
return result
} else {
errorList.add(UtilProperties.getMessage("ContentUiLabels", "ContentNoUploadedContentFound", parameters.locale))
}
}
String uploadPath = null
switch (mode) {
case ["LOCAL_FILE", "LOCAL_FILE_BIN"]:
uploadPath = DataResourceWorker.getDataResourceContentUploadPath(delegator, true)
break
case ["OFBIZ_FILE", "OFBIZ_FILE_BIN"]:
uploadPath = DataResourceWorker.getDataResourceContentUploadPath(delegator, false)
break
case ["CONTEXT_FILE", "CONTEXT_FILE_BIN"]:
uploadPath = parameters.rootDir
break
}
if (!uploadPath) {
errorList.add(UtilProperties.getMessage("ContentErrorUiLabels", "uploadContentAndImage.noRootDirProvided", parameters.locale))
}
if (errorList) {
return ServiceUtil.returnError(errorList)
}
logInfo("[attachLocalFileToDataResource] - Found Subdir : ${uploadPath}")
GenericValue extension = from("FileExtension")
.where("mimeTypeId", parameters._uploadedFile_contentType)
.queryFirst()
dataResource.dataResourceName = parameters._uploadedFile_fileName
dataResource.objectInfo = extension ?
"${uploadPath}/${dataResource.dataResourceId}.${extension.fileExtensionId}" :
"${uploadPath}/${dataResource.dataResourceId}"
dataResource.dataResourceTypeId = parameters.dataResourceTypeId
dataResource.store()
ModelService cafService = dispatcher.getDispatchContext().getModelService("createAnonFile")
Map fileCtx = cafService.makeValid(dataResource, "IN")
fileCtx.binData = parameters.uploadedFile
fileCtx.dataResource = dataResource
result = run service: "createAnonFile", with: fileCtx
result.dataResourceId = dataResource.dataResourceId
result.mimeTypeId = dataResource.mimeTypeId
return result
}
def saveExtFileDataResource(boolean isUpdate, String mode) {
Map result = success()
List errorList = []
GenericValue dataResource = from("DataResource")
.where("dataResourceId", parameters.dataResourceId)
.queryOne()
if (!dataResource) {
errorList.add(UtilProperties.getMessage("ContentUiLabels", "ContentDataResourceNotFound", parameters.locale))
}
if (!parameters._uploadedFile_fileName) {
if (isUpdate) {
// upload is found on an update; its okay, don't do anything just return
result.dataResourceId = dataResource.dataResourceId
result.mimeTypeId = dataResource.mimeTypeId
return result
} else {
errorList.add(UtilProperties.getMessage("ContentUiLabels", "ContentNoUploadedContentFound", parameters.locale))
}
}
// update the data resource with file data
dataResource.dataResourceTypeId = parameters.dataResourceTypeId
dataResource.dataResourceName = parameters._uploadedFile_fileName
dataResource.mimeTypeId = parameters._uploadedFile_contentType
dataResource.store()
Map serviceContext = prepareServiceContext(dataResource, mode)
if (isUpdate) {
switch (mode) {
case "IMAGE_OBJECT":
result = run service: "updateImageDataResource", with: serviceContext
break
case "VIDEO_OBJECT":
result = run service: "updateVideoDataResource", with: serviceContext
break
case "AUDIO_OBJECT":
result = run service: "updateAudioDataResource", with: serviceContext
break
case "OTHER_OBJECT":
result = run service: "updateOtherDataResource", with: serviceContext
break
}
} else {
switch (mode) {
case "IMAGE_OBJECT":
result = run service: "createImageDataResource", with: serviceContext
break
case "VIDEO_OBJECT":
result = run service: "createVideoDataResource", with: serviceContext
break
case "AUDIO_OBJECT":
result = run service: "createAudioDataResource", with: serviceContext
break
case "OTHER_OBJECT":
result = run service: "createOtherDataResource", with: serviceContext
break
}
}
result.dataResourceId = dataResource.dataResourceId
result.mimeTypeId = dataResource.mimeTypeId
return result
}
Map prepareServiceContext(GenericValue dataResource, String mode) {
switch (mode) {
case "IMAGE_OBJECT":
ModelService service = dispatcher.getDispatchContext().getModelService("createImageDataResource")
Map serviceContext = service.makeValid(dataResource, "IN")
serviceContext.imageData = parameters.uploadedFile
serviceContext.dataResource = dataResource
return serviceContext
case "VIDEO_OBJECT":
ModelService service = dispatcher.getDispatchContext().getModelService("updateVideoDataResource")
Map serviceContext = service.makeValid(dataResource, "IN")
serviceContext.videoData = parameters.uploadedFile
return serviceContext
case "AUDIO_OBJECT":
ModelService service = dispatcher.getDispatchContext().getModelService("createAudioDataResource")
Map serviceContext = service.makeValid(dataResource, "IN")
serviceContext.audioData
return serviceContext
case "OTHER_OBJECT":
ModelService service = dispatcher.getDispatchContext().getModelService("createOtherDataResource")
Map serviceContext = service.makeValid(dataResource, "IN")
serviceContext.dataResourceContent = parameters.uploadedFile
return serviceContext
}
return error
}