Code refactoring help - how to refactor checks

We have a web application that uses user logins or database searches to create some operations on some physical resources. The design can be simply represented as the following diagram:

user input <=> model object <=> database store

validations are required with a query coming from user input, but NOT when coming from database lookup queries (since, if a record exists, these attributes must be validated earlier). I'm trying to refactor my code so that checks are done in the object's constructor instead of the old one (several separate check routines)

How would you decide which path is best? (The main difference between method 1 (old way) and 2 is that checks in 1 are optional and not associated with an object instance, but 2 binds them and makes them mandatory for all requests)

Here are two code examples for design 1 and 2:

Method 1:

# For processing single request.
# Steps: 1. Validate all incoming data. 2. instantiate the object.
ValidateAttribures(request) # raise Exceptions if failed
resource = Resource(**request)

      

        
        
        
      

    

Method 2:

# Have to extract out this since it does not have anything to do with
# the object.
# raise Exceptions if some required params missing.
# steps: 1. Check whether its a batching request. 2. instantiate the object.
#           (validations are performed inside the constructor)
CheckIfBatchRequest(request) 
resource = Resource(**request) # raise Exceptions when validations failed

      

        
        
        
      

    

In a batch request: Method 1:

# steps: 1. validate each request and return error to the client if any found.
#        2. perform the object instantiate and creation process. Exceptions are
#           captured.
#        3. when all finished, email out any errors.
for request in batch_requests:
    try:    
        ValidateAttribute(request)
    except SomeException, e:
        return ErrorPage(e)
errors = []
for request in batch_requests:
    try:
        CreatResource(Resource(**request), request)
    except CreationError, e:
        errors.append('failed to create with error: %s', e)
email(errors)

      

        
        
        
      

    

Method 2:

# steps: 1. validate batch job related data from the request.
#        2. If success, create objects for each request and do the validations.
#        3. If exception, return error found, otherwise, 
#           return a list of pairs with (object, request)
#        4. Do the creation process and email out any errors if encountered.
CheckIfBatchRequest(request)
request_objects = []
for request in batch_requests:
    try:
        resource = Resource(**request)
    except SomeException, e:
        return ErrorPage(e)
    request_objects.append((resource, request))
email(CreateResource(request_objects)) # the CreateResource will also need to be refactored.

      

        
        
        
      

    

Pros and cons as I see here:

• Method 1 follows closer to business logic. No redundant checks checking objects when looking up db. Verification procedures are better maintained and read.
• Method 2 simplifies and cleans up the caller. Validations are required even if from db search. Checks are less repairable and less readable.