class BookingService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.Booking = self.ec.InitEntityClass('Booking')
self.service_account = AccountService()
def get_booking_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.Booking).select_all()
return result
return None
def get_booking_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(self.Booking).select_by_id(idValue)
return result
return None
def add_booking(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.Booking):
with self.base_service.DbContext() as __context:
modelAdmin = self.service_account.get_accountAdmin(
) # get limit 1 result
# create new object of Booking
modelBooking = self.Booking()
modelBooking.BookingId = str(self.util_common.generateUUID())
modelBooking.AccountBookerId = hasattr(
paramModel,
'AccountBookerId') and paramModel.AccountBookerId or None
modelBooking.PropPriceId = hasattr(
paramModel,
'PropPriceId') and paramModel.PropPriceId or None
modelBooking.DateArrival = hasattr(
paramModel,
'DateArrival') and paramModel.DateArrival or None
modelBooking.DateCheckout = hasattr(
paramModel,
'DateCheckout') and paramModel.DateCheckout or None
modelBooking.DateActualArrival = hasattr(
paramModel, 'DateActualArrival'
) and paramModel.DateActualArrival or None
modelBooking.DateActualCheckout = hasattr(
paramModel, 'DateActualCheckout'
) and paramModel.DateActualCheckout or None
modelBooking.TotalPeople = hasattr(
paramModel,
'TotalPeople') and paramModel.TotalPeople or None
modelBooking.PriceDealed = hasattr(
paramModel,
'PriceDealed') and paramModel.PriceDealed or None
modelBooking.DepositDealed = hasattr(
paramModel,
'DepositDealed') and paramModel.DepositDealed or None
modelBooking.PaymentDateInMonth = hasattr(
paramModel, 'PaymentDateInMonth'
) and paramModel.PaymentDateInMonth or None
modelBooking.CreatedBy = modelAdmin.IndexNo
modelBooking.LastModifiedBy = modelAdmin.IndexNo
modelBooking.DateCreated = str(
self.util_common.currentDateTime())
modelBooking.DateLastModified = str(
self.util_common.currentDateTime())
# insert to db
result = __context.table(
self.Booking).insert_by_model(modelBooking)
if result:
return modelBooking
return None
def update_booking(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.Booking):
modelBookingFromDb = self.get_booking_byId(paramModel.BookingId)
if (modelBookingFromDb is not None):
modelAdmin = self.service_account.get_accountAdmin(
) # get limit 1 result
modelBookingFromDb.AccountBookerId = hasattr(
paramModel, 'AccountBookerId'
) and paramModel.AccountBookerId or modelBookingFromDb.AccountBookerId
modelBookingFromDb.PropPriceId = hasattr(
paramModel, 'PropPriceId'
) and paramModel.PropPriceId or modelBookingFromDb.PropPriceId
modelBookingFromDb.DateArrival = hasattr(
paramModel, 'DateArrival'
) and paramModel.DateArrival or modelBookingFromDb.DateArrival
modelBookingFromDb.DateCheckout = hasattr(
paramModel, 'DateCheckout'
) and paramModel.DateCheckout or modelBookingFromDb.DateCheckout
modelBookingFromDb.DateActualArrival = hasattr(
paramModel, 'DateActualArrival'
) and paramModel.DateActualArrival or modelBookingFromDb.DateActualArrival
modelBookingFromDb.DateActualCheckout = hasattr(
paramModel, 'DateActualCheckout'
) and paramModel.DateActualCheckout or modelBookingFromDb.DateActualCheckout
modelBookingFromDb.TotalPeople = hasattr(
paramModel, 'TotalPeople'
) and paramModel.TotalPeople or modelBookingFromDb.TotalPeople
modelBookingFromDb.PriceDealed = hasattr(
paramModel, 'PriceDealed'
) and paramModel.PriceDealed or modelBookingFromDb.PriceDealed
modelBookingFromDb.DepositDealed = hasattr(
paramModel, 'DepositDealed'
) and paramModel.DepositDealed or modelBookingFromDb.DepositDealed
modelBookingFromDb.PaymentDateInMonth = hasattr(
paramModel, 'PaymentDateInMonth'
) and paramModel.PaymentDateInMonth or modelBookingFromDb.PaymentDateInMonth
modelBookingFromDb.LastModifiedBy = modelAdmin.IndexNo
modelBookingFromDb.DateLastModified = str(
self.util_common.currentDateTime())
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(
self.Booking).update_by_model(modelBookingFromDb)
if result:
return modelBookingFromDb
return None
class CountryService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.Country = self.ec.InitEntityClass('Country')
self.service_account = AccountService()
def get_country_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.Country).select_all()
return result
return None
def get_country_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(self.Country).select_by_id(idValue)
return result
return None
def get_country_byName(self, searchText):
with self.base_service.DbContext() as __context:
conditions = ''' Name like '%{0}%' '''.format(searchText)
result = __context.table(self.Country).select_by(conditions)
return result
return None
def get_country_byCode(self, searchText):
with self.base_service.DbContext() as __context:
conditions = ''' CountryCode like '%{0}%' '''.format(searchText)
result = __context.table(self.Country).select_by(conditions)
return result
return None
def add_country(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.Country):
with self.base_service.DbContext() as __context:
modelLastCountry = __context.table(
self.Country).select_lastrecord(
) # get last record of Country table to increment IndexNo
# create new object of Country
modelCountry = self.Country()
modelCountry.CountryId = modelLastCountry.CountryId + 1
modelCountry.Name = hasattr(paramModel,
'Name') and paramModel.Name or None
modelCountry.CountryCode = hasattr(
paramModel,
'CountryCode') and paramModel.CountryCode or None
modelCountry.SortOrder = hasattr(
paramModel, 'SortOrder') and paramModel.SortOrder or None
modelCountry.IsAvailable = hasattr(
paramModel, 'IsAvailable') and paramModel.IsAvailable or 1
# insert to db
result = __context.table(
self.Country).insert_by_model(modelCountry)
if result:
return modelCountry
return None
def update_country(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.Country):
modelCountryFromDb = self.get_country_byId(paramModel.CountryId)
if (modelCountryFromDb is not None):
modelCountryFromDb.Name = hasattr(
paramModel,
'Name') and paramModel.Name or modelCountryFromDb.Name
modelCountryFromDb.CountryCode = hasattr(
paramModel, 'CountryCode'
) and paramModel.CountryCode or modelCountryFromDb.CountryCode
modelCountryFromDb.SortOrder = hasattr(
paramModel, 'SortOrder'
) and paramModel.SortOrder or modelCountryFromDb.SortOrder
modelCountryFromDb.IsAvailable = hasattr(
paramModel, 'IsAvailable'
) and paramModel.IsAvailable or modelCountryFromDb.IsAvailable
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(
self.Country).update_by_model(modelCountryFromDb)
if result:
return modelCountryFromDb
return None
class BookingPaymentService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.BookingPayment = self.ec.InitEntityClass('BookingPayment')
self.service_account = AccountService()
def get_bookingpayment_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.BookingPayment).select_all()
return result
return None
def get_bookingpayment_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(self.BookingPayment).select_by_id(idValue)
return result
return None
def add_bookingpayment(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.BookingPayment):
with self.base_service.DbContext() as __context:
modelAdmin = self.service_account.get_accountAdmin(
) # get limit 1 result
# create new object of BookingPayment
modelBookingPayment = self.BookingPayment()
modelBookingPayment.BookingPaymentId = str(
self.util_common.generateUUID())
modelBookingPayment.BookingId = hasattr(
paramModel, 'BookingId') and paramModel.BookingId or None
modelBookingPayment.DepositAmount = hasattr(
paramModel,
'DepositAmount') and paramModel.DepositAmount or 0
modelBookingPayment.DepositPaid = hasattr(
paramModel, 'DepositPaid') and paramModel.DepositPaid or 0
modelBookingPayment.FixedAmount = hasattr(
paramModel, 'FixedAmount') and paramModel.FixedAmount or 0
modelBookingPayment.FixedPaid = hasattr(
paramModel, 'FixedPaid') and paramModel.FixedPaid or 0
modelBookingPayment.DateApplied = hasattr(
paramModel,
'DateApplied') and paramModel.DateApplied or None
modelBookingPayment.DateEnd = hasattr(
paramModel, 'DateEnd') and paramModel.DateEnd or None
modelBookingPayment.IsClosed = hasattr(
paramModel, 'IsClosed') and paramModel.IsClosed or 0
modelBookingPayment.CreatedBy = modelAdmin.IndexNo
modelBookingPayment.LastModifiedBy = modelAdmin.IndexNo
modelBookingPayment.DateCreated = str(
self.util_common.currentDateTime())
modelBookingPayment.DateLastModified = str(
self.util_common.currentDateTime())
# insert to db
result = __context.table(
self.BookingPayment).insert_by_model(modelBookingPayment)
if result:
return modelBookingPayment
return None
def update_bookingpayment(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.BookingPayment):
modelBookingPaymentFromDb = self.get_bookingpayment_byId(
paramModel.BookingPaymentId)
if (modelBookingPaymentFromDb is not None):
modelAdmin = self.service_account.get_accountAdmin(
) # get limit 1 result
modelBookingPaymentFromDb.BookingId = hasattr(
paramModel, 'BookingId'
) and paramModel.BookingId or modelBookingPaymentFromDb.BookingId
modelBookingPaymentFromDb.DepositAmount = hasattr(
paramModel, 'DepositAmount'
) and paramModel.DepositAmount or modelBookingPaymentFromDb.DepositAmount
modelBookingPaymentFromDb.DepositPaid = hasattr(
paramModel, 'DepositPaid'
) and paramModel.DepositPaid or modelBookingPaymentFromDb.DepositPaid
modelBookingPaymentFromDb.FixedAmount = hasattr(
paramModel, 'FixedAmount'
) and paramModel.FixedAmount or modelBookingPaymentFromDb.FixedAmount
modelBookingPaymentFromDb.FixedPaid = hasattr(
paramModel, 'FixedPaid'
) and paramModel.FixedPaid or modelBookingPaymentFromDb.FixedPaid
modelBookingPaymentFromDb.DateApplied = hasattr(
paramModel, 'DateApplied'
) and paramModel.DateApplied or modelBookingPaymentFromDb.DateApplied
modelBookingPaymentFromDb.DateEnd = hasattr(
paramModel, 'DateEnd'
) and paramModel.DateEnd or modelBookingPaymentFromDb.DateEnd
modelBookingPaymentFromDb.IsClosed = hasattr(
paramModel, 'IsClosed'
) and paramModel.IsClosed or modelBookingPaymentFromDb.IsClosed
modelBookingPaymentFromDb.LastModifiedBy = modelAdmin.IndexNo
modelBookingPaymentFromDb.DateLastModified = str(
self.util_common.currentDateTime())
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(
self.BookingPayment).update_by_model(
modelBookingPaymentFromDb)
if result:
return modelBookingPaymentFromDb
return None
class TimeUnitService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.TimeUnit = self.ec.InitEntityClass('TimeUnit')
self.service_account = AccountService()
def get_timeunit_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.TimeUnit).select_all()
return result
return None
def get_timeunit_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(self.TimeUnit).select_by_id(idValue)
return result
return None
def get_timeunit_byName(self, searchText):
with self.base_service.DbContext() as __context:
conditions = ''' Name like '%{0}%' '''.format(searchText)
result = __context.table(self.TimeUnit).select_by(conditions)
return result
return None
def add_timeunit(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.TimeUnit):
with self.base_service.DbContext() as __context:
modelLastTimeUnit = __context.table(
self.TimeUnit).select_lastrecord(
) # get last record of TimeUnit table to increment IndexNo
# create new object of TimeUnit
modelTimeUnit = self.TimeUnit()
modelTimeUnit.TimeUnitId = modelLastTimeUnit.TimeUnitId + 1
modelTimeUnit.Name = hasattr(
paramModel, 'Name') and paramModel.Name or None
modelTimeUnit.Description = hasattr(
paramModel,
'Description') and paramModel.Description or None
modelTimeUnit.ToHours = hasattr(
paramModel, 'ToHours') and paramModel.ToHours or None
modelTimeUnit.ToHoursLeapYear = hasattr(
paramModel,
'ToHoursLeapYear') and paramModel.ToHoursLeapYear or None
modelTimeUnit.SortOrder = hasattr(
paramModel, 'SortOrder') and paramModel.SortOrder or None
modelTimeUnit.IsAvailable = hasattr(
paramModel, 'IsAvailable') and paramModel.IsAvailable or 1
# insert to db
result = __context.table(
self.TimeUnit).insert_by_model(modelTimeUnit)
if result:
return modelTimeUnit
return None
def update_timeunit(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.TimeUnit):
modelTimeUnitFromDb = self.get_timeunit_byId(paramModel.TimeUnitId)
if (modelTimeUnitFromDb is not None):
modelTimeUnitFromDb.Name = hasattr(
paramModel,
'Name') and paramModel.Name or modelTimeUnitFromDb.Name
modelTimeUnitFromDb.Description = hasattr(
paramModel, 'Description'
) and paramModel.Description or modelTimeUnitFromDb.Description
modelTimeUnitFromDb.ToHours = hasattr(
paramModel, 'ToHours'
) and paramModel.ToHours or modelTimeUnitFromDb.ToHours
modelTimeUnitFromDb.ToHoursLeapYear = hasattr(
paramModel, 'ToHoursLeapYear'
) and paramModel.ToHoursLeapYear or modelTimeUnitFromDb.ToHoursLeapYear
modelTimeUnitFromDb.SortOrder = hasattr(
paramModel, 'SortOrder'
) and paramModel.SortOrder or modelTimeUnitFromDb.SortOrder
modelTimeUnitFromDb.IsAvailable = hasattr(
paramModel, 'IsAvailable'
) and paramModel.IsAvailable or modelTimeUnitFromDb.IsAvailable
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(
self.TimeUnit).update_by_model(modelTimeUnitFromDb)
if result:
return modelTimeUnitFromDb
return None
class ClientService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.Client = self.ec.InitEntityClass('Client')
self.service_account = AccountService()
def get_client_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.Client).select_all()
return result
return None
def get_client_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(self.Client).select_by_id(idValue)
return result
return None
def get_client_byName(self, searchText):
with self.base_service.DbContext() as __context:
conditions = ''' FullName like '%{0}%' '''.format(searchText)
result = __context.table(self.Client).select_by(conditions)
return result
return None
def add_client(self, paramModel):
if( paramModel is not None and inspect.isclass(type(paramModel)) and type(paramModel) == self.Client):
with self.base_service.DbContext() as __context:
modelAdmin = self.service_account.get_accountAdmin()# get limit 1 result
modelLastClient = __context.table(self.Client).select_lastrecord()# get last record of Client table to increment IndexNo
# create new object of Client
modelClient = self.Client()
modelClient.ClientId = str(self.util_common.generateUUID())
modelClient.IndexNo = hasattr(paramModel, 'IndexNo') and paramModel.IndexNo or (modelLastClient.IndexNo + 1)
modelClient.BookerFgCode = hasattr(paramModel, 'BookerFgCode') and paramModel.BookerFgCode or '00000000'
modelClient.IdentityPicture = hasattr(paramModel, 'IdentityPicture') and paramModel.IdentityPicture or None
modelClient.IdentityCardId = hasattr(paramModel, 'IdentityCardId') and paramModel.IdentityCardId or None
modelClient.FullName = hasattr(paramModel, 'FullName') and paramModel.FullName.upper() or None
modelClient.FourgramCode = hasattr(paramModel, 'FullName') and self.__generateFourgramCode(paramModel.FullName) or None
modelClient.Phone1 = hasattr(paramModel, 'Phone1') and paramModel.Phone1 or None
modelClient.Phone2 = hasattr(paramModel, 'Phone2') and paramModel.Phone2 or None
modelClient.Email = hasattr(paramModel, 'Email') and paramModel.Email or None
modelClient.TemporaryAddress = hasattr(paramModel, 'TemporaryAddress') and paramModel.TemporaryAddress or None
modelClient.CurrentJob = hasattr(paramModel, 'CurrentJob') and paramModel.CurrentJob or None
modelClient.SignatureScan = hasattr(paramModel, 'SignatureScan') and paramModel.SignatureScan or None
modelClient.IsAvailable = hasattr(paramModel, 'IsAvailable') and paramModel.IsAvailable or 1
modelClient.CreatedBy = modelAdmin.IndexNo
modelClient.LastModifiedBy = modelAdmin.IndexNo
modelClient.DateCreated = str(self.util_common.currentDateTime())
modelClient.DateLastModified = str(self.util_common.currentDateTime())
# insert to db
result = __context.table(self.Client).insert_by_model(modelClient)
if result:
return modelClient
return None
def update_client(self, paramModel):
if(paramModel is not None and inspect.isclass(type(paramModel)) and type(paramModel) == self.Client):
modelClientFromDb = self.get_client_byId(paramModel.ClientId)
if(modelClientFromDb is not None):
modelAdmin = self.service_account.get_accountAdmin()# get limit 1 result
modelClientFromDb.IndexNo = hasattr(paramModel, 'IndexNo') and paramModel.IndexNo or modelClientFromDb.IndexNo
modelClientFromDb.BookerFgCode = hasattr(paramModel, 'BookerFgCode') and paramModel.BookerFgCode or modelClientFromDb.BookerFgCode
modelClientFromDb.IdentityPicture = hasattr(paramModel, 'IdentityPicture') and paramModel.IdentityPicture or modelClientFromDb.IdentityPicture
modelClientFromDb.FullName = hasattr(paramModel, 'FullName') and paramModel.FullName.upper() or modelClientFromDb.FullName
modelClientFromDb.Phone1 = hasattr(paramModel, 'Phone1') and paramModel.Phone1 or modelClientFromDb.Phone1
modelClientFromDb.Phone2 = hasattr(paramModel, 'Phone2') and paramModel.Phone2 or modelClientFromDb.Phone2
modelClientFromDb.Email = hasattr(paramModel, 'Email') and paramModel.Email or modelClientFromDb.Email
modelClientFromDb.TemporaryAddress = hasattr(paramModel, 'TemporaryAddress') and paramModel.TemporaryAddress or modelClientFromDb.TemporaryAddress
modelClientFromDb.CurrentJob = hasattr(paramModel, 'CurrentJob') and paramModel.CurrentJob or modelClientFromDb.CurrentJob
modelClientFromDb.SignatureScan = hasattr(paramModel, 'SignatureScan') and paramModel.SignatureScan or modelClientFromDb.SignatureScan
modelClientFromDb.IsAvailable = hasattr(paramModel, 'IsAvailable') and paramModel.IsAvailable or modelClientFromDb.IsAvailable
modelClientFromDb.LastModifiedBy = modelAdmin.IndexNo
modelClientFromDb.DateLastModified = str(self.util_common.currentDateTime())
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(self.Client).update_by_model(modelClientFromDb)
if result:
return modelClientFromDb
return None
def __generateFourgramCode(self, fullname):
if fullname:
fourgramcode = ''
lstWord = fullname.strip().split(' ')
firstWord = lstWord[0]
lastWord = lstWord[len(lstWord) - 1]
finalChars = str(lastWord[:2]).upper() + str(firstWord[:2]).upper()# get first 2 character of string
with self.base_service.DbContext() as __context:
conditions = ''' FourgramCode like '%{0}%' ORDER BY FourgramCode DESC LIMIT 1'''.format(finalChars)
result = __context.table(self.Client).select_by(conditions)
if result:
# lastDigitFCode = result[0].FourgramCode[-4:]
lastDigitFCode = ''.join([n for n in list(result[0].FourgramCode) if n.isdigit()])
fourgramcode = finalChars + str("{:04d}".format(int(lastDigitFCode) + 1))
else:
fourgramcode = finalChars + "{:04d}".format(1)# display number leading zeros with format 4 digits
return fourgramcode
return None
class PropertyAvailibiltyTypeService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.PropertyAvailibiltyType = self.ec.InitEntityClass(
'PropertyAvailibiltyType')
self.service_account = AccountService()
def get_propavailtype_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.PropertyAvailibiltyType).select_all()
return result
return None
def get_propavailtype_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(
self.PropertyAvailibiltyType).select_by_id(idValue)
return result
return None
def get_propavailtype_byName(self, searchText):
with self.base_service.DbContext() as __context:
conditions = ''' Name like '%{0}%' '''.format(searchText)
result = __context.table(
self.PropertyAvailibiltyType).select_by(conditions)
return result
return None
def add_propavailtype(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.PropertyAvailibiltyType):
with self.base_service.DbContext() as __context:
modelLastPropertyAvailibiltyType = __context.table(
self.PropertyAvailibiltyType
).select_lastrecord(
) # get last record of PropertyAvailibiltyType table to increment IndexNo
# create new object of PropertyAvailibiltyType
modelPropertyAvailibiltyType = self.PropertyAvailibiltyType()
modelPropertyAvailibiltyType.PropAvailTypeId = modelLastPropertyAvailibiltyType.PropAvailTypeId + 1
modelPropertyAvailibiltyType.Name = hasattr(
paramModel, 'Name') and paramModel.Name or None
modelPropertyAvailibiltyType.Description = hasattr(
paramModel,
'Description') and paramModel.Description or None
modelPropertyAvailibiltyType.SortOrder = hasattr(
paramModel, 'SortOrder') and paramModel.SortOrder or None
modelPropertyAvailibiltyType.IsAvailable = hasattr(
paramModel, 'IsAvailable') and paramModel.IsAvailable or 1
# insert to db
result = __context.table(
self.PropertyAvailibiltyType).insert_by_model(
modelPropertyAvailibiltyType)
if result:
return modelPropertyAvailibiltyType
return None
def update_propavailtype(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.PropertyAvailibiltyType):
modelPropertyAvailibiltyTypeFromDb = self.get_propavailtype_byId(
paramModel.PropAvailTypeId)
if (modelPropertyAvailibiltyTypeFromDb is not None):
modelPropertyAvailibiltyTypeFromDb.Name = hasattr(
paramModel, 'Name'
) and paramModel.Name or modelPropertyAvailibiltyTypeFromDb.Name
modelPropertyAvailibiltyTypeFromDb.Description = hasattr(
paramModel, 'Description'
) and paramModel.Description or modelPropertyAvailibiltyTypeFromDb.Description
modelPropertyAvailibiltyTypeFromDb.SortOrder = hasattr(
paramModel, 'SortOrder'
) and paramModel.SortOrder or modelPropertyAvailibiltyTypeFromDb.SortOrder
modelPropertyAvailibiltyTypeFromDb.IsAvailable = hasattr(
paramModel, 'IsAvailable'
) and paramModel.IsAvailable or modelPropertyAvailibiltyTypeFromDb.IsAvailable
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(
self.PropertyAvailibiltyType).update_by_model(
modelPropertyAvailibiltyTypeFromDb)
if result:
return modelPropertyAvailibiltyTypeFromDb
return None
class PropertyPricePolicyService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.PropertyPricePolicy = self.ec.InitEntityClass(
'PropertyPricePolicy')
self.service_account = AccountService()
def get_proppricepol_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.PropertyPricePolicy).select_all()
return result
return None
def get_proppricepol_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(
self.PropertyPricePolicy).select_by_id(idValue)
return result
return None
def add_proppricepol(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.PropertyPricePolicy):
with self.base_service.DbContext() as __context:
modelAdmin = self.service_account.get_accountAdmin(
) # get limit 1 result
modelLastPropertyPricePolicy = __context.table(
self.PropertyPricePolicy
).select_lastrecord(
) # get last record of PropertyPricePolicy table to increment IndexNo
# create new object of PropertyPricePolicy
modelPropertyPricePolicy = self.PropertyPricePolicy()
modelPropertyPricePolicy.PropPriceId = modelLastPropertyPricePolicy.PropPriceId + 1
modelPropertyPricePolicy.PropertyItemId = hasattr(
paramModel,
'PropertyItemId') and paramModel.PropertyItemId or None
modelPropertyPricePolicy.TimeUnitId = hasattr(
paramModel, 'TimeUnitId') and paramModel.TimeUnitId or None
modelPropertyPricePolicy.CostActual = hasattr(
paramModel, 'CostActual') and paramModel.CostActual or None
modelPropertyPricePolicy.PriceOrigin = hasattr(
paramModel,
'PriceOrigin') and paramModel.PriceOrigin or None
modelPropertyPricePolicy.PercentageDiscount = hasattr(
paramModel, 'PercentageDiscount'
) and paramModel.PercentageDiscount or None
modelPropertyPricePolicy.PriceActual = hasattr(
paramModel,
'PriceActual') and paramModel.PriceActual or None
modelPropertyPricePolicy.DepositAmount = hasattr(
paramModel,
'DepositAmount') and paramModel.DepositAmount or None
modelPropertyPricePolicy.DateApplied = hasattr(
paramModel,
'DateApplied') and paramModel.DateApplied or None
modelPropertyPricePolicy.IsConfirmed = hasattr(
paramModel, 'IsConfirmed') and paramModel.IsConfirmed or 0
modelPropertyPricePolicy.CreatedBy = modelAdmin.IndexNo
modelPropertyPricePolicy.LastModifiedBy = modelAdmin.IndexNo
modelPropertyPricePolicy.DateCreated = str(
self.util_common.currentDateTime())
modelPropertyPricePolicy.DateLastModified = str(
self.util_common.currentDateTime())
# insert to db
result = __context.table(
self.PropertyPricePolicy).insert_by_model(
modelPropertyPricePolicy)
if result:
return modelPropertyPricePolicy
return None
def update_proppricepol(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.PropertyPricePolicy):
modelPropertyPricePolicyFromDb = self.get_proppricepol_byId(
paramModel.PropPriceId)
if (modelPropertyPricePolicyFromDb is not None):
modelAdmin = self.service_account.get_accountAdmin(
) # get limit 1 result
modelPropertyPricePolicyFromDb.PropertyItemId = hasattr(
paramModel, 'PropertyItemId'
) and paramModel.PropertyItemId or modelPropertyPricePolicyFromDb.PropertyItemId
modelPropertyPricePolicyFromDb.TimeUnitId = hasattr(
paramModel, 'TimeUnitId'
) and paramModel.TimeUnitId or modelPropertyPricePolicyFromDb.TimeUnitId
modelPropertyPricePolicyFromDb.CostActual = hasattr(
paramModel, 'CostActual'
) and paramModel.CostActual or modelPropertyPricePolicyFromDb.CostActual
modelPropertyPricePolicyFromDb.PriceOrigin = hasattr(
paramModel, 'PriceOrigin'
) and paramModel.PriceOrigin or modelPropertyPricePolicyFromDb.PriceOrigin
modelPropertyPricePolicyFromDb.PercentageDiscount = hasattr(
paramModel, 'PercentageDiscount'
) and paramModel.PercentageDiscount or modelPropertyPricePolicyFromDb.PercentageDiscount
modelPropertyPricePolicyFromDb.PriceActual = hasattr(
paramModel, 'PriceActual'
) and paramModel.PriceActual or modelPropertyPricePolicyFromDb.PriceActual
modelPropertyPricePolicyFromDb.DepositAmount = hasattr(
paramModel, 'DepositAmount'
) and paramModel.DepositAmount or modelPropertyPricePolicyFromDb.DepositAmount
modelPropertyPricePolicyFromDb.DateApplied = hasattr(
paramModel, 'DateApplied'
) and paramModel.DateApplied or modelPropertyPricePolicyFromDb.DateApplied
modelPropertyPricePolicyFromDb.IsConfirmed = hasattr(
paramModel, 'IsConfirmed'
) and paramModel.IsConfirmed or modelPropertyPricePolicyFromDb.IsConfirmed
modelPropertyPricePolicyFromDb.LastModifiedBy = modelAdmin.IndexNo
modelPropertyPricePolicyFromDb.DateLastModified = str(
self.util_common.currentDateTime())
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(
self.PropertyPricePolicy).update_by_model(
modelPropertyPricePolicyFromDb)
if result:
return modelPropertyPricePolicyFromDb
return None
class PropertyItemService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.PropertyItem = self.ec.InitEntityClass('PropertyItem')
self.service_account = AccountService()
def get_propitem_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.PropertyItem).select_all()
return result
return None
def get_propitem_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(self.PropertyItem).select_by_id(idValue)
return result
return None
def get_propitem_byName(self, searchText):
with self.base_service.DbContext() as __context:
conditions = ''' FullName like '%{0}%' '''.format(searchText)
result = __context.table(self.PropertyItem).select_by(conditions)
return result
return None
def add_propitem(self, paramModel):
if( paramModel is not None and inspect.isclass(type(paramModel)) and type(paramModel) == self.PropertyItem):
with self.base_service.DbContext() as __context:
modelAdmin = self.service_account.get_accountAdmin()# get limit 1 result
modelLastPropertyItem = __context.table(self.PropertyItem).select_lastrecord()# get last record of PropertyItem table to increment IndexNo
# create new object of PropertyItem
modelPropertyItem = self.PropertyItem()
modelPropertyItem.PropertyItemId = str(self.util_common.generateUUID())
modelPropertyItem.IndexNo = hasattr(paramModel, 'IndexNo') and paramModel.IndexNo or (modelLastPropertyItem.IndexNo + 1)
modelPropertyItem.ParentId = hasattr(paramModel, 'ParentId') and paramModel.ParentId or None
modelPropertyItem.PropertyId = hasattr(paramModel, 'PropertyId') and paramModel.PropertyId or None
modelPropertyItem.PropertyTypeId = hasattr(paramModel, 'PropertyTypeId') and paramModel.PropertyTypeId or None
modelPropertyItem.PropertyStatusId = hasattr(paramModel, 'PropertyStatusId') and paramModel.PropertyStatusId or None
modelPropertyItem.PropAvailTypeId = hasattr(paramModel, 'PropAvailTypeId') and paramModel.PropAvailTypeId or None
modelPropertyItem.Name = hasattr(paramModel, 'Name') and paramModel.Name or None
modelPropertyItem.ShortDescription = hasattr(paramModel, 'ShortDescription') and paramModel.ShortDescription or None
modelPropertyItem.LongDescription = hasattr(paramModel, 'LongDescription') and paramModel.LongDescription or None
modelPropertyItem.FloorNo = hasattr(paramModel, 'FloorNo') and paramModel.FloorNo or None
modelPropertyItem.RoomName = hasattr(paramModel, 'RoomName') and paramModel.RoomName or None
modelPropertyItem.Width = hasattr(paramModel, 'Width') and paramModel.Width or 0
modelPropertyItem.Length = hasattr(paramModel, 'Length') and paramModel.Length or 0
modelPropertyItem.AreaUsage = hasattr(paramModel, 'AreaUsage') and paramModel.AreaUsage or 0
modelPropertyItem.MaxAllowPeople = hasattr(paramModel, 'MaxAllowPeople') and paramModel.MaxAllowPeople or None
modelPropertyItem.LastElectricalUsageNo = hasattr(paramModel, 'LastElectricalUsageNo') and paramModel.LastElectricalUsageNo or None
modelPropertyItem.LastWaterUsageNo = hasattr(paramModel, 'LastWaterUsageNo') and paramModel.LastWaterUsageNo or None
modelPropertyItem.IsAvailable = hasattr(paramModel, 'IsAvailable') and paramModel.IsAvailable or 1
modelPropertyItem.IsRemoved = hasattr(paramModel, 'IsRemoved') and paramModel.IsRemoved or 0
modelPropertyItem.CreatedBy = modelAdmin.IndexNo
modelPropertyItem.LastModifiedBy = modelAdmin.IndexNo
modelPropertyItem.DateCreated = str(self.util_common.currentDateTime())
modelPropertyItem.DateLastModified = str(self.util_common.currentDateTime())
# insert to db
result = __context.table(self.PropertyItem).insert_by_model(modelPropertyItem)
if result:
return modelPropertyItem
return None
def update_propitem(self, paramModel):
if(paramModel is not None and inspect.isclass(type(paramModel)) and type(paramModel) == self.PropertyItem):
modelPropertyItemFromDb = self.get_propitem_byId(paramModel.PropertyItemId)
if(modelPropertyItemFromDb is not None):
modelAdmin = self.service_account.get_accountAdmin()# get limit 1 result
modelPropertyItemFromDb.IndexNo = hasattr(paramModel, 'IndexNo') and paramModel.IndexNo or modelPropertyItemFromDb.IndexNo
modelPropertyItemFromDb.ParentId = hasattr(paramModel, 'ParentId') and paramModel.ParentId or modelPropertyItemFromDb.ParentId
modelPropertyItemFromDb.PropertyId = hasattr(paramModel, 'PropertyId') and paramModel.PropertyId or modelPropertyItemFromDb.PropertyId
modelPropertyItemFromDb.PropertyTypeId = hasattr(paramModel, 'PropertyTypeId') and paramModel.PropertyTypeId or modelPropertyItemFromDb.PropertyTypeId
modelPropertyItemFromDb.PropertyStatusId = hasattr(paramModel, 'PropertyStatusId') and paramModel.PropertyStatusId or modelPropertyItemFromDb.PropertyStatusId
modelPropertyItemFromDb.PropAvailTypeId = hasattr(paramModel, 'PropAvailTypeId') and paramModel.PropAvailTypeId or modelPropertyItemFromDb.PropAvailTypeId
modelPropertyItemFromDb.Name = hasattr(paramModel, 'Name') and paramModel.Name or modelPropertyItemFromDb.Name
modelPropertyItemFromDb.ShortDescription = hasattr(paramModel, 'ShortDescription') and paramModel.ShortDescription or modelPropertyItemFromDb.ShortDescription
modelPropertyItemFromDb.LongDescription = hasattr(paramModel, 'LongDescription') and paramModel.LongDescription or modelPropertyItemFromDb.LongDescription
modelPropertyItemFromDb.FloorNo = hasattr(paramModel, 'FloorNo') and paramModel.FloorNo or modelPropertyItemFromDb.FloorNo
modelPropertyItemFromDb.RoomName = hasattr(paramModel, 'RoomName') and paramModel.RoomName or modelPropertyItemFromDb.RoomName
modelPropertyItemFromDb.Width = hasattr(paramModel, 'Width') and paramModel.Width or modelPropertyItemFromDb.Width
modelPropertyItemFromDb.Length = hasattr(paramModel, 'Length') and paramModel.Length or modelPropertyItemFromDb.Length
modelPropertyItemFromDb.AreaUsage = hasattr(paramModel, 'AreaUsage') and paramModel.AreaUsage or modelPropertyItemFromDb.AreaUsage
modelPropertyItemFromDb.MaxAllowPeople = hasattr(paramModel, 'MaxAllowPeople') and paramModel.MaxAllowPeople or modelPropertyItemFromDb.MaxAllowPeople
modelPropertyItemFromDb.LastElectricalUsageNo = hasattr(paramModel, 'LastElectricalUsageNo') and paramModel.LastElectricalUsageNo or modelPropertyItemFromDb.LastElectricalUsageNo
modelPropertyItemFromDb.LastWaterUsageNo = hasattr(paramModel, 'LastWaterUsageNo') and paramModel.LastWaterUsageNo or modelPropertyItemFromDb.LastWaterUsageNo
modelPropertyItemFromDb.IsAvailable = hasattr(paramModel, 'IsAvailable') and paramModel.IsAvailable or 1
modelPropertyItemFromDb.IsRemoved = hasattr(paramModel, 'IsRemoved') and paramModel.IsRemoved or 0
modelPropertyItemFromDb.LastModifiedBy = modelAdmin.IndexNo
modelPropertyItemFromDb.DateLastModified = str(self.util_common.currentDateTime())
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(self.PropertyItem).update_by_model(modelPropertyItemFromDb)
if result:
return modelPropertyItemFromDb
return None
class AccountService():
def __init__(self):
self.base_service = BaseService()
self.db = BaseService.DbFilePath
self.ec = self.base_service.Entity()
self.util_common = self.base_service.UtilCommon()
self.util_security = self.base_service.UtilSecurity()
self.Account = self.ec.InitEntityClass('Account')
def get_account_all(self):
with self.base_service.DbContext() as __context:
result = __context.table(self.Account).select_all()
return result
return None
def get_account_byId(self, idValue):
with self.base_service.DbContext() as __context:
result = __context.table(self.Account).select_by_id(idValue)
return result
return None
def get_account_byUname(self, searchText):
with self.base_service.DbContext() as __context:
conditions = ''' Username like '%{0}%' '''.format(searchText)
result = __context.table(self.Account).select_by(conditions)
return result
return None
def get_accountAdmin(self):
with self.base_service.DbContext() as __context:
conditions = ''' IsMasterAdmin = 1 '''
result = __context.table(self.Account).select_by(conditions)
return result[0]
return None
def add_account(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.Account):
with self.base_service.DbContext() as __context:
modelAdmin = self.get_accountAdmin() # get limit 1 result
modelLastAccount = __context.table(
self.Account).select_lastrecord(
) # get last record of Account table to increment IndexNo
password = hasattr(
paramModel,
'Pw') and paramModel.Pw or self.util_common.randomString(8)
hashedpassword = self.util_security.generatePasswordByBcrypt(
password, 6) # generate hashed password using bcrypt
# create new object of Account
modelAcc = self.Account()
modelAcc.AccountId = str(self.util_common.generateUUID())
modelAcc.IndexNo = hasattr(
paramModel, 'IndexNo') and paramModel.IndexNo or (
modelLastAccount.IndexNo + 1)
modelAcc.Username = hasattr(
paramModel, 'Username') and paramModel.Username or None
modelAcc.IsBooker = hasattr(
paramModel, 'IsBooker') and paramModel.IsBooker or 1
modelAcc.IpAddress = hasattr(
paramModel, 'IpAddress') and paramModel.IpAddress or None
modelAcc.Pw = hashedpassword
modelAcc.SaltKey = hasattr(
paramModel, 'SaltKey') and paramModel.SaltKey or None
modelAcc.IsAvailable = hasattr(
paramModel, 'IsAvailable') and paramModel.IsAvailable or 1
modelAcc.CreatedBy = modelAdmin.IndexNo
modelAcc.LastModifiedBy = modelAdmin.IndexNo
modelAcc.DateCreated = str(self.util_common.currentDateTime())
modelAcc.DateLastModified = str(
self.util_common.currentDateTime())
# insert to db
result = __context.table(
self.Account).insert_by_model(modelAcc)
if result:
return modelAcc
return None
def update_account(self, paramModel):
if (paramModel is not None and inspect.isclass(type(paramModel))
and type(paramModel) == self.Account):
modelAccFromDb = self.get_account_byId(paramModel.AccountId)
if (modelAccFromDb is not None):
modelAdmin = self.get_accountAdmin() # get limit 1 result
modelAccFromDb.Pw = (
# if paramModel.Pw (new password) has value and it not matched exist password
(hasattr(paramModel, 'Pw')
and not self.util_security.verifyHashed(
self.util_security, paramModel.Pw, modelAccFromDb.Pw))
# then generate new hashed password for new password
and self.util_security.generatePasswordByBcrypt(
paramModel.Pw, 6)
# else if they matched together, get exist password
or modelAccFromDb.Pw)
modelAccFromDb.IndexNo = hasattr(
paramModel,
'IndexNo') and paramModel.IndexNo or modelAccFromDb.IndexNo
modelAccFromDb.Username = hasattr(
paramModel, 'Username'
) and paramModel.Username or modelAccFromDb.Username
modelAccFromDb.IsBooker = hasattr(
paramModel, 'IsBooker'
) and paramModel.IsBooker or modelAccFromDb.IsBooker
modelAccFromDb.IsMasterAdmin = hasattr(
paramModel, 'IsMasterAdmin'
) and paramModel.IsMasterAdmin or modelAccFromDb.IsMasterAdmin
modelAccFromDb.IpAddress = hasattr(
paramModel, 'IpAddress'
) and paramModel.IpAddress or modelAccFromDb.IpAddress
modelAccFromDb.DateLastLogin = hasattr(
paramModel, 'DateLastLogin'
) and paramModel.DateLastLogin or modelAccFromDb.DateLastLogin
modelAccFromDb.IsAvailable = hasattr(
paramModel, 'IsAvailable'
) and paramModel.IsAvailable or modelAccFromDb.IsAvailable
modelAccFromDb.LastModifiedBy = modelAdmin.IndexNo
modelAccFromDb.DateLastModified = str(
self.util_common.currentDateTime())
with self.base_service.DbContext() as __context:
# update to db
result = __context.table(
self.Account).update_by_model(modelAccFromDb)
if result:
return modelAccFromDb
return None