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 validateDelete(ownerId, propertyId):
errors = []
if not PersistenceValidator.checkExists(Property, propertyId):
errors.append(
PersistenceValidator.entityDoesNotExist(
"Property", "id", propertyId))
else:
PropertyValidator.checkOwner(errors, ownerId, propertyId)
rentals = ReadOnlyAccess.getEntityListCopy(
Rental, {"property": propertyId})
viewings = ReadOnlyAccess.getEntityListCopy(
Viewing, {"propertyId": propertyId})
rentals = list(
filter(
lambda x: Date.after(Date.toDate(x.end), Date.now()) and x.
status == RentalStatus.CONFIRMED, rentals))
viewings = list(
filter(lambda x: Date.after(Date.toDate(x.date), Date.now()),
viewings))
if len(rentals) > 0:
errors.append(
PersistenceValidator.activeSubEntitiesExist(
"Property", "Rentals", len(rentals)))
if len(viewings) > 0:
errors.append(
PersistenceValidator.activeSubEntitiesExist(
"Property", "Viewings", len(viewings)))
return BaseValidator.getValidationMessage(errors)
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 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(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 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(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 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 validateDelete(accountId):
errors = []
properties = ReadOnlyAccess.getEntityListCopy(Property, {"ownerId": accountId})
rentals = ReadOnlyAccess.getEntityListCopy(Rental, {"customer": accountId})
rentals.extend(ReadOnlyAccess.getEntityListCopy(Rental, {"agent": accountId}))
rentals = list(filter(lambda x: Date.after(Date.toDate(x.end), Date.now()) and x.status == RentalStatus.CONFIRMED, rentals))
viewings = ReadOnlyAccess.getEntityListCopy(Viewing, {"customerId": accountId})
viewings = list(filter(lambda x: Date.after(Date.toDate(x.date), Date.now()), rentals))
if len(properties) > 0:
errors.append(PersistenceValidator.subEntitiesExist("Account", "Properties", len(properties)))
if len(rentals) > 0:
errors.append(PersistenceValidator.activeSubEntitiesExist("Account", "Rentals", len(rentals)))
if len(viewings) > 0:
errors.append(PersistenceValidator.activeSubEntitiesExist("Account", "Viewings", len(viewings)))
return BaseValidator.getValidationMessage(errors)
def readAll(customerId):
# Validate in persistence level
validatorResponse = RentalValidator.validateReadAll(customerId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Read Entities
searchFilter = {"customer": customerId}
rentalList = ReadOnlyAccess.getEntityListCopy(Rental, searchFilter)
# Return Result
return {FieldKey.SUCCESS: rentalList}
def readAll(propertyId):
# Validate in persistence level
validatorResponse = ImageValidator.validateReadAll(propertyId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Read Entities
searchFilter = {"propertyId": propertyId}
imageList = ReadOnlyAccess.getEntityListCopy(
Image, {"propertyId": propertyId})
# Return Result
return {FieldKey.SUCCESS: imageList}
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(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(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 readList(customerId):
# Validate in persistence level
validatorResponse = ViewingValidator.validateReadAll(customerId)
if FieldKey.ERROR in validatorResponse:
return validatorResponse
# Read Entities
searchFilter = {"customerId": customerId}
viewingList = ReadOnlyAccess.getEntityListCopy(Viewing, searchFilter)
viewingList = list(
filter(lambda x: Date.after(Date.toDate(x.date), Date.now()),
viewingList))
return {FieldKey.SUCCESS: viewingList}
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 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 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 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))
