def getAccount(sessionToken):
session = ReadOnlyAccess.getEntityCopy(Session, sessionToken)
if session is None:
return False, None
if SessionUtility.isExpired(session):
return False, None
return True, ReadOnlyAccess.getEntityListCopy(Account, {"username": session.username})[0]
def allowOwnerOf(self, cEntity, accountField, entityId):
entity = ReadOnlyAccess.getEntityCopy(cEntity, entityId)
if entity is not None:
accountId = getattr(entity, accountField)
if accountId == self.account.id:
self.passed = True
return self
def validateUpdate(image):
errors = []
if PersistenceValidator.checkExists(Image, image.id):
original = ReadOnlyAccess.getEntityCopy(Image, image.id)
else:
original = Image()
errors.append(PersistenceValidator.entityDoesNotExist("Image", "id", image.id))
return BaseValidator.getValidationMessage(ImageValidator.checkUniqueness(errors, image, original))
def validateDelete(rentalId):
errors = RentalValidator.validateRead(rentalId)
rental = ReadOnlyAccess.getEntityCopy(Rental, rentalId)
if Date.after(Date.toDate(rental.end),
Date.now()) and rental.status == RentlStatus.CONFIRMED:
errors.append(PersistenceValidator.entityActive(
"Rental", rentalId))
return BaseValidator.getValidationMessage(errors)
def validateUpdate(account):
errors = []
if PersistenceValidator.checkExists(Account, account.id):
original = ReadOnlyAccess.getEntityCopy(Account, account.id)
else:
original = Account()
errors.append(PersistenceValidator.entityDoesNotExist("Account", "id", account.id))
return BaseValidator.getValidationMessage(AccountValidator.checkUniqueness(errors, account, original))
def read(rentalId):
# Validate in persistence level
validatorResponse = RentalValidator.validateRead(rentalId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Read Entity
rental = ReadOnlyAccess.getEntityCopy(Rental, rentalId)
# Return Result
return {FieldKey.SUCCESS: rental}
def validateRead(propertyId, imageId):
errors = []
if not PersistenceValidator.checkExists(Image, imageId):
errors.append(PersistenceValidator.entityDoesNotExist("Image", "id", imageId))
if not PersistenceValidator.checkExists(Property, propertyId):
errors.append(PersistenceValidator.entityDoesNotExist("Property", "id", propertyId))
if not ReadOnlyAccess.getEntityCopy(Image, imageId).propertyId == propertyId:
errors.append(linkedDomainNotFoundError("Property", "Image", propertyId, imageId))
return BaseValidator.getValidationMessage(errors)
def read(propertyId, imageId):
# Validate in persistence level
validatorResponse = ImageValidator.validateRead(propertyId, imageId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Create and process Tasks
property = ReadOnlyAccess.getEntityCopy(Property, propertyId)
# Return Result
path = FileSystemUtil.getPath("images", property.ownerId)
return os.path.join(path, imageId + ".jpg"), 'image/jpg'
def remove(propertyId, imageId):
# Validate in persistence level
validatorResponse = ImageValidator.validateDelete(propertyId, imageId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Get return copy, before delete
image = ReadOnlyAccess.getEntityCopy(Image, imageId)
property = ReadOnlyAccess.getEntityCopy(Property, propertyId)
# Create and process Tasks
processor = TaskProcessor()
processor.add(
RemoveFromFileSystemTask("images", property.ownerId, imageId,
"jpg"))
processor.add(DetachForeignKeyTask(Property, "mainImageId", imageId))
processor.add(DeleteEntityTask(Image, imageId))
processor.add(FlushDirectoryTask("images", []))
processor.process()
# Return Result
return {FieldKey.SUCCESS: image}
def read(customerId, viewingId):
# Validate in persistence level
validatorResponse = ViewingValidator.validateRead(
customerId, viewingId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Create and process Tasks
viewing = ReadOnlyAccess.getEntityCopy(Viewing, viewingId)
# Return Result
return {FieldKey.SUCCESS: viewing}
def validateUpdate(viewing):
errors = []
if PersistenceValidator.checkExists(Viewing, viewing.id):
original = ReadOnlyAccess.getEntityCopy(Viewing, viewing.id)
else:
original = Viewing()
errors.append(
PersistenceValidator.entityDoesNotExist(
"Viewing", "id", viewing.id))
return BaseValidator.getValidationMessage(
ViewingValidator.checkUniqueness(errors, viewing, original))
def validateUpdate(rental):
errors = []
if PersistenceValidator.checkExists(Rental, rental.id):
original = ReadOnlyAccess.getEntityCopy(Rental, rental.id)
else:
original = Rental()
errors.append(
PersistenceValidator.entityDoesNotExist(
"Rental", "id", rental.id))
return BaseValidator.getValidationMessage(
RentalValidator.checkUniqueness(errors, rental, original))
def validateUpdate(ownerId, property):
errors = []
if PersistenceValidator.checkExists(Property, property.id):
original = ReadOnlyAccess.getEntityCopy(Property, property.id)
PropertyValidator.checkOwner(errors, ownerId, property.id)
else:
original = Property()
errors.append(
PersistenceValidator.entityDoesNotExist(
"Property", "id", property.id))
return BaseValidator.getValidationMessage(
PropertyValidator.checkUniqueness(errors, property, original))
def validateReadAll(ownerId):
errors = []
if not PersistenceValidator.checkExists(Account, ownerId):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Owner", "id", ownerId))
elif not ReadOnlyAccess.getEntityCopy(
Account, ownerId).type == AccountType.OWNER:
errors.append(
PersistenceValidator.entityDoesNotExist(
"Owner", "id", ownerId))
return BaseValidator.getValidationMessage(errors)
def update(updatedImage):
# Validate in persistence level
validatorResponse = ImageValidator.validateUpdate(updatedImage)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Create and process Tasks
processor = TaskProcessor()
processor.add(
UpdateEntityTask(Image, ImageService.mergeImages, updatedImage))
processor.process()
# Return Result
image = ReadOnlyAccess.getEntityCopy(Image, updatedImage.id)
return {FieldKey.SUCCESS: image}
def validateCreate(property):
errors = []
if not PersistenceValidator.checkExists(Account, property.ownerId):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Owner", "id", property.ownerId))
elif not ReadOnlyAccess.getEntityCopy(
Account, property.ownerId).type == AccountType.OWNER:
errors.append(
PersistenceValidator.entityDoesNotExist(
"Owner", "id", property.ownerId))
return BaseValidator.getValidationMessage(
PropertyValidator.checkUniqueness(errors, property))
def delete(customerId, viewingId):
# Validate in persistence level
validatorResponse = ViewingValidator.validateDelete(
customerId, viewingId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Get return copy, before delete
viewing = ReadOnlyAccess.getEntityCopy(Viewing, viewingId)
# Create and process Tasks
processor = TaskProcessor()
processor.add(DeleteEntityTask(Viewing, viewingId))
processor.process()
# Return Result
return {FieldKey.SUCCESS: viewing}
def update(updatedRental):
# Validate in persistence level
validatorResponse = RentalValidator.validateUpdate(updatedRental)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Create and process Tasks
processor = TaskProcessor()
processor.add(
UpdateEntityTask(Rental, RentalService.mergeRentals,
updatedRental))
processor.process()
# Return Result
rental = ReadOnlyAccess.getEntityCopy(Rental, updatedRental.id)
return {FieldKey.SUCCESS: rental}
def update(updatedViewing):
# Validate in persistence level
validatorResponse = ViewingValidator.validateUpdate(updatedViewing)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Create and process Tasks
processor = TaskProcessor()
processor.add(
UpdateEntityTask(Viewing, ViewingService.mergeViewings,
updatedViewing))
processor.process()
# Return Result
viewing = ReadOnlyAccess.getEntityCopy(Viewing, updatedViewing.id)
return {FieldKey.SUCCESS: viewing}
def validateCreate(username, password):
errors = []
accounts = ReadOnlyAccess.getEntityListCopy(Account,
{"username": username})
if len(accounts) > 1:
raise Exception("Multiple Accounts with Username: " + username)
elif len(accounts) < 1:
errors.append(SessionValidator.incorrectUsernameOrPassword())
else:
credential = ReadOnlyAccess.getEntityCopy(Credential,
accounts[0].id)
if credential is None or not PasswordUtility.checkHashedPassword(
password, credential.password):
errors.append(SessionValidator.incorrectUsernameOrPassword())
return BaseValidator.getValidationMessage(errors)
def add(image):
# Validate in persistence level
validatorResponse = ImageValidator.validateCreate(image)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Get Property Info
property = ReadOnlyAccess.getEntityCopy(Property, image.propertyId)
# Create and process Tasks
processor = TaskProcessor()
processor.add(
SaveToFileSystemTask("images", property.ownerId, image.id,
image.file, "jpg"))
processor.add(SaveNewEntityTask(image))
processor.process()
# Return Result
return {FieldKey.SUCCESS: image}
def validateRead(customerId, viewingId):
errors = []
if not PersistenceValidator.checkExists(Account, customerId):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Customer", "id", customerId))
if not PersistenceValidator.checkExists(Viewing, viewingId):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Viewing", "id", viewingId))
if not ReadOnlyAccess.getEntityCopy(
Viewing, viewingId).customerId == customerId:
errors.append(
PersistenceValidator.linkedDomainNotFoundError(
"Customer", "Viewing", customerId, viewingId))
return errors
def validateCreate(viewing):
errors = []
if not PersistenceValidator.checkExists(Account, viewing.customerId):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Customer", "id", viewing.customerId))
elif not ReadOnlyAccess.getEntityCopy(
Account, viewing.customerId).type == AccountType.CUSTOMER:
errors.append(
PersistenceValidator.entityDoesNotExist(
"Customer", "id", viewing.customerId))
if not PersistenceValidator.checkExists(Property, viewing.propertyId):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Property", "id", viewing.propertyId))
return BaseValidator.getValidationMessage(
ViewingValidator.checkUniqueness(errors, viewing.propertyId))
def setMain(propertyId, imageId):
# Validate in persistence level
validatorResponse = ImageValidator.validateSetMain(propertyId, imageId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Create Updated Property
updatedProperty = Property()
updatedProperty.id = propertyId
updatedProperty.mainImageId = imageId
# Create and process Tasks
processor = TaskProcessor()
processor.add(
UpdateEntityTask(Property, PropertyService.mergeProperties,
updatedProperty))
processor.process()
property = ReadOnlyAccess.getEntityCopy(Property, propertyId)
return {FieldKey.SUCCESS: property}
def validateCreate(rental):
errors = []
if not PersistenceValidator.checkExists(Account, rental.customer):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Customer", "id", rental.customer))
elif not ReadOnlyAccess.getEntityCopy(
Account, rental.customer).type == AccountType.CUSTOMER:
errors.append(
PersistenceValidator.entityDoesNotExist(
"Customer", "id", rental.customer))
if not PersistenceValidator.checkExists(Property, rental.property):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Property", "id", rental.property))
if not PersistenceValidator.checkExists(Property, rental.property):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Property", "id", rental.property))
return BaseValidator.getValidationMessage(
RentalValidator.checkUniqueness(errors, rental))
def checkOwner(errors, ownerId, propertyId):
if not ReadOnlyAccess.getEntityCopy(Property,
propertyId).ownerId == ownerId:
errors.append(
PersistenceValidator.linkedDomainNotFoundError(
"Owner", "Property", ownerId, propertyId))