Python DataModel.deleteAttributeValue方法代码示例

# 需要导入模块: import DataModel [as 别名]
# 或者: from DataModel import deleteAttributeValue [as 别名]
def process_delete_attr_form(global_config, form):
    global_config['logger'].debug( 'Process Attribute Delete Form' )

    season = form[attr_delete_season_label].value
    comp = form[attr_delete_comp_label].value
    team = form[attr_delete_team_number_label].value
    attr_name = form[attr_delete_attribute_name_label].value
    old_value = form[attr_delete_old_value_label].value
    
    # Initialize the database session connection
    db_name  = global_config['db_name'] + global_config['this_season']
    session  = DbSession.open_db_session(db_name)
    
    attrdef_filename = WebCommonUtils.get_attrdef_filename(short_comp=comp)
    if attrdef_filename is not None:
        attr_definitions = AttributeDefinitions.AttrDefinitions(global_config)
        attr_definitions.parse(attrdef_filename)
        attr_def = attr_definitions.get_definition(attr_name)

        try:
            DataModel.deleteAttributeValue(session, team, comp+season, attr_name, old_value, attr_def)
            result = 'Scouting Data Attribute Value %s Successfully Removed From %s' % (old_value,attr_name)
            session.commit()
        except ValueError as reason:   
            result = 'Error Removing Scouting Data Attribute Value %s From %s: %s' % (old_value,attr_name,reason)
                
    session.remove()
    return result

# 需要导入模块: import DataModel [as 别名]
# 或者: from DataModel import deleteAttributeValue [as 别名]
def remove_file_data(global_config, session, attr_definitions, data_filename, remove_from_processed_files=False):
    print 'removing data file: %s'%data_filename
    
    competition = global_config['this_competition'] + global_config['this_season']
    input_dir = './static/data/' + competition + '/ScoutingData/'
    filepath = input_dir+data_filename
    # Initialize the file_attributes dictionary in preparation for the
    # parsing of the data file
    file_attributes = {}
    
    # Parse the data file, removing all the information in the file_attributes
    # dictionary
    try:
        FileParser.FileParser(filepath).parse(file_attributes)
    except:
        raise ValueError('Error Opening File')

    # The team number can be retrieved from the Team attribute, one of the
    # mandatory attributes within the data file
    team = file_attributes['Team']
    
    # Also, extract the competition name, too, if it has been included in
    # the data file
    if file_attributes.has_key('Competition'):
        competition = file_attributes['Competition']
    else:
        competition = global_config['this_competition'] + global_config['this_season']

        if competition == None:
            raise Exception( 'Competition Not Specified!')
    
    # Loop through the attributes from the data file and post them to the
    # database
    for attribute, value in file_attributes.iteritems():
        if value is None:
            value = ''
        attr_definition = attr_definitions.get_definition(attribute)
        if attr_definition == None:
            raise ValueError( 'No Attribute Defined For Attribute: %s' % attribute )
        elif attr_definition['Database_Store']=='Yes':
            DataModel.deleteAttributeValue(session, team, competition, attribute, value, attr_definition, no_throw=True)
            
    if remove_from_processed_files:
        DataModel.deleteProcessedFile(session, filepath)

    score = DataModel.calculateTeamScore(session, team, competition, attr_definitions)
    DataModel.setTeamScore(session, team, competition, score)

# 需要导入模块: import DataModel [as 别名]
# 或者: from DataModel import deleteAttributeValue [as 别名]
def remove_json_file_data(global_config, request_path):

    # Initialize the database session connection
    db_name  = global_config['db_name'] + global_config['this_season']
    session  = DbSession.open_db_session(db_name)

    if request_path.startswith('static'):
        fullpath = './' + request_path

        if os.path.exists(fullpath) is False:
            return

        competition = request_path.split('/')[2]

        print 'Removing scouting data from JSON file: %s' % fullpath
        filename = fullpath.split('/')[-1]

        with open(fullpath) as fd:
            scouting_data = json.load(fd)
            if filename.startswith('Match'):
                team = scouting_data['Setup'].get('Team')
            elif filename.startswith('Pit'):
                team = scouting_data['Pit'].get('Team')

            if team is not None and len(team) > 0:
                attr_definitions = AttributeDefinitions.AttrDefinitions(global_config)
                for section_name, section_data in scouting_data.iteritems():
                    if isinstance(section_data,dict):
                        for attr_name, attr_value in section_data.iteritems():

                            # use the attribute definitions to control whether information gets
                            # stored to the database rather than the hard coded stuff here.
                            # also need to consider the section/category name as the attributes
                            # and definitions are processed

                            # don't store the team number in the database
                            if attr_name == 'Team':
                                continue

                            # augment the attribute name with the section name in order to make the attribute
                            # unique
                            attr_name = '%s:%s' % (section_name, attr_name)

                            attribute_def = {}
                            attribute_def['Name'] = attr_name
                            if attr_value.isdigit():
                                attribute_def['Type'] = 'Integer'
                                attribute_def['Weight'] = 1.0
                            else:
                                attribute_def['Type'] = 'String'
                                attribute_def['Weight'] = 0.0
                            attribute_def['Statistic_Type'] = 'Average'
                            attr_definitions.add_definition(attribute_def)

                            category = 'Match'
                            try:
                                DataModel.deleteAttributeValue(session, int(team), competition, 
                                                               attr_name, attr_value, attribute_def)
                            except Exception, exception:
                                traceback.print_exc(file=sys.stdout)
                                exc_type, exc_value, exc_traceback = sys.exc_info()
                                exception_info = traceback.format_exception(exc_type, exc_value,exc_traceback)
                                for line in exception_info:
                                    line = line.replace('\n','')
                                    global_config['logger'].debug(line)
                    else:
                        print 'Unexpected entry in scouting data file, name: %s, value: %s' % (section_name,section_data)

                score = DataModel.calculateTeamScore(session, int(team), competition, attr_definitions)
                DataModel.setTeamScore(session, int(team), competition, score)
                session.commit()