def get_bids(self): """"Get the bids of all players in order.""" self.bids = Bids() blind_accepted = False for i in range(4): # The value of 'dealer' will have been incremented at the end of the deal # Hence, it's current value is the player who should start bidding active_player_id = (self.dealer + i) % 4 # First, we have to check if a Blind Nill bid is allowed, and if so, offer the option if not blind_accepted and self.score.can_blind(active_player_id): if self.players[active_player_id].offer_blind_nill(self.bids.make_copy(active_player_id)): blind_accepted = True self.bids.add_bid(_BLIND_NILL_CHARACTER, active_player_id) self.players[active_player_id].give_hand(deepcopy(self.hands[active_player_id])) continue # Hand out the cards to the player and ask for a bid self.players[active_player_id].give_hand(deepcopy(self.hands[active_player_id])) player_bid = self.players[active_player_id].make_bid(self.bids.make_copy(active_player_id)) # Make sure the bid is valid: between 0 and 13, and the sum with the teammate's bid does not exceed 13 assert 0 <= player_bid <= 13 teammate_id = (active_player_id + 2) % 4 if teammate_id in self.bids and (self.bids[teammate_id] != "N" and self.bids[teammate_id] != "B"): assert self.bids[(active_player_id + 2) % 4] + player_bid <= 13 self.bids.add_bid(player_bid, active_player_id) # When all bids have been made, inform all players about them for i, player in enumerate(self.players): player.announce_bids(self.bids.make_copy(i))
def __init__(self, players=[IPlayer()]*4, playing_to=500): self.players = players self.playing_to = playing_to self.score = Score() # Players 0 and 2 form team 0, players 1 and 3 are team 1 self.hands = {} self.dealer = 0 self.bids = Bids()
def get_bids(self): """"Get the bids of all players in order.""" self.bids = Bids() blind_accepted = False for i in range(4): # The value of 'dealer' will have been incremented at the end of the deal # Hence, it's current value is the player who should start bidding active_player_id = (self.dealer + i) % 4 # First, we have to check if a Blind Nill bid is allowed, and if so, offer the option if not blind_accepted and self.score.can_blind(active_player_id): if self.players[active_player_id].offer_blind_nill( self.bids.make_copy(active_player_id)): blind_accepted = True self.bids.add_bid(_BLIND_NILL_CHARACTER, active_player_id) self.players[active_player_id].give_hand( deepcopy(self.hands[active_player_id])) continue # Hand out the cards to the player and ask for a bid self.players[active_player_id].give_hand( deepcopy(self.hands[active_player_id])) self.bids.add_bid( self.players[active_player_id].make_bid( self.bids.make_copy(active_player_id)), active_player_id) # When all bids have been made, inform all players about them for i, player in enumerate(self.players): player.announce_bids(self.bids.make_copy(i))
class GameManagerSIMD: def for_all(self, player, player_x, functor, param=None): """" Helper function to loop though all our games. """ assert len(param) == len(self.gameData) or param is None data = [game_state if game_state.is_player_x(player_x, player) else None for game_state in self.gameData] if param is None: return [None if d is None else functor(d) for d in data] else: return [None if data[i] is None or param[i] is None else functor(data[i], param[i]) for i in range(len(data))] def __init__(self, players=[IPlayer()] * 4, playing_to=500): self.players = players self.gameData = [] self.playing_to = playing_to self.score = Score() # Players 0 and 2 form team 0, players 1 and 3 are team 1 self.hands = {} self.dealer = 0 self.bids = Bids() def get_blind_player_x(self, x): for player in self.players: known_bids = self.for_all(player, x, lambda gs: gs.bids if gs.can_do_blind(x) else None) # TODO: deep copy and make relative id. bids = player.offer_blind_nill(known_bids) self.for_all(player, x, lambda gs, bid: gs.set_blind_player(x) if gs.can_do_blind(x) and bid else None, bids) def set_hand_player_x(self, x): for player in self.players: hands = self.for_all(player, x, lambda gs: gs.get_hand(x)) player.give_hand(hands) def get_bid_x(self, x): for player in self.players: known_bids = self.for_all(player, x, lambda gs: gs.bids if not gs.is_blind_player(x) else None) # TODO: deep copy and make relative id. bids = player.make_bid(known_bids) self.for_all(player, x, lambda gs, bid: gs.set_bid_player(x, bid) if not gs.is_blind_player(x) else None, bids) def announce_bids(self): for player in self.players: bids = [gs.get_bid_announce(player) for gs in self.gameData] player.announce_bids(bids) def swap_blind_player_cards(self, x): teammate_x = (x + 2) % 4 for i in range(len(self.players)): player = self.players[i] team_player = self.players[(i+2) % 4] requests = self.for_all(player, x, lambda gs: True if gs.is_blind_player(x) else None) cards = player.request_blind_nill_cards(requests) self.for_all(player, x, lambda gs, c: gs.take_cards(x, c) if gs.is_blind_player(x) else None, cards) team_player.receive_blind_nill_cards(cards) self.for_all(team_player, teammate_x, lambda gs, c: gs.give_cards(teammate_x) if gs.is_blind_player(x) else None, cards) def swap_teammate_player_cards(self, x): blind_mate_x = (x + 2) % 4 for i in range(len(self.players)): player = self.players[i] blind_player = self.players[(i+2) % 4] requests = self.for_all(player, x, lambda gs: True if gs.is_blind_player(blind_mate_x) else None) cards = player.request_blind_nill_cards(requests) self.for_all(player, x, lambda gs, c: gs.take_cards(x, c) if gs.is_blind_player(blind_mate_x) else None, cards) blind_player.receive_blind_nill_cards(cards) self.for_all(blind_player, blind_mate_x, lambda gs, c: gs.give_cards(blind_mate_x) if gs.is_blind_player(blind_mate_x) else None, cards) def deal_deck(self): """ Shuffle the deck and deal 13 cards to each player. Note that for Blind Nill purposes, the handing out of cards happens during the bidding phase. """ deck = [] for suit_id in range(4): for number_id in range(13): deck.append(card.Card(suit_id, number_id)) random.shuffle(deck) for i in range(4): hand = deck[13 * i: 13 * (i + 1)] self.hands[i] = hand self.dealer = (self.dealer + 1) % 4 def get_bids(self): """"Get the bids of all players in order.""" self.bids = Bids() blind_accepted = False for i in range(4): # The value of 'dealer' will have been incremented at the end of the deal # Hence, it's current value is the player who should start bidding active_player_id = (self.dealer + i) % 4 # First, we have to check if a Blind Nill bid is allowed, and if so, offer the option if not blind_accepted and self.score.can_blind(active_player_id): if self.players[active_player_id].offer_blind_nill(self.bids.make_copy(active_player_id)): blind_accepted = True self.bids.add_bid(_BLIND_NILL_CHARACTER, active_player_id) self.players[active_player_id].give_hand(deepcopy(self.hands[active_player_id])) continue # Hand out the cards to the player and ask for a bid self.players[active_player_id].give_hand(deepcopy(self.hands[active_player_id])) player_bid = self.players[active_player_id].make_bid(self.bids.make_copy(active_player_id)) # Make sure the bid is valid: between 0 and 13, and the sum with the teammate's bid does not exceed 13 assert 0 <= player_bid <= 13 teammate_id = (active_player_id + 2) % 4 if teammate_id in self.bids and (self.bids[teammate_id] != "N" and self.bids[teammate_id] != "B"): assert self.bids[(active_player_id + 2) % 4] + player_bid <= 13 self.bids.add_bid(player_bid, active_player_id) # When all bids have been made, inform all players about them for i, player in enumerate(self.players): player.announce_bids(self.bids.make_copy(i)) def handle_card_exchange(self): """"Exchanges 2 cards between the players of the team running a Blind Nill.""" assert self.bids.get_blinder_id() is not None blinder_id = self.bids.get_blinder_id() # Step 1: Get 2 cards from the person running the Blind Nill and give them to the teammate # Step 2: Get 2 cards from the teammate and give them to the person running the Blind Nill for i in [0, 2]: giver_id = (blinder_id + i) % 4 receiver_id = (giver_id + 2) % 4 offered_cards = deepcopy(self.players[giver_id].request_blind_nill_cards()) # As always, don't trust the players, and check all conditions assert len(offered_cards) == 2 for offered_card in offered_cards: assert offered_card in self.hands[giver_id] self.hands[giver_id].remove(offered_card) self.players[receiver_id].receive_blind_nill_cards(deepcopy(offered_cards)) self.hands[receiver_id] += offered_cards def get_trick(self, starting_player, spades_broken): """"Play a trick by getting a card from each player in order.""" current_trick = Trick() for i in range(4): player_id = (starting_player + i) % 4 card_played = self.players[player_id].play_card(current_trick.make_copy(player_id), self.get_valid_cards(player_id, current_trick, spades_broken)) assert self.verify_card_validity(card_played, player_id, current_trick, spades_broken) current_trick.add_card(card_played, player_id) self.hands[player_id].remove(card_played) return current_trick def verify_card_validity(self, played_card, player_id, trick, spades_broken): """"Verify that an offered card is valid to play.""" try: # First off, a card can only be played if the player actually has it assert played_card in self.hands[player_id] # Secondly, check if the card is of the right suit # If the player starts the trick or matches the suit, all is fine if trick.suit is not None and played_card.suit != trick.suit: for hand_card in self.hands[player_id]: assert hand_card.suit != trick.suit # Thirdly, a player may only start a trick with a spade if a spade has been played before, # or if the player only has spades left in his hand if trick.suit is None and played_card.suit == "S" and not spades_broken: for hand_card in self.hands[player_id]: assert hand_card.suit == "S" except AssertionError: return False return True def get_valid_cards(self, player_id, trick, spades_broken): """"Generate a list of all cards in a player's hand that are valid to play for this trick.""" valid_cards = [] for hand_card in self.hands[player_id]: if self.verify_card_validity(hand_card, player_id, trick, spades_broken): valid_cards.append(hand_card) return deepcopy(valid_cards) def play_round(self): """"Play a round, consisting of 13 tricks.""" # Set up the round spades_broken = False self.deal_deck() starting_player = self.dealer self.get_bids() trick_count = {0: 0, 1: 0, 2: 0, 3: 0} if self.bids.get_blinder_id() is not None: self.handle_card_exchange() # Play the round for i in range(13): current_trick = self.get_trick(starting_player, spades_broken) if current_trick.won_by_spade: spades_broken = True starting_player = current_trick.get_winner() trick_count[starting_player] += 1 # Inform all players of the final result of the trick for i, player in enumerate(self.players): player.announce_trick(current_trick.make_copy(i)) # Handle the scoring for i in [0, 1]: self.award_team_score(trick_count, i) # Inform all players about the new score for i, player in enumerate(self.players): player.announce_score(self.score.make_copy(i)) def award_team_score(self, trick_count, team_id): """"Given the bids and a resulting trick count, decide the score for a team.""" assert team_id == 0 or team_id == 1 gained_score = 0 handled = False player_1_id = 0 + team_id player_2_id = 2 + team_id # First, handle the situation of a player nilling if self.bids.team_has_nill(team_id): for player_id in [player_1_id, player_2_id]: bid = self.bids[player_id] tricks = trick_count[player_id] if bid == "N" or bid == "B": multiplier = 1 + int(bid == "B") if tricks == 0: gained_score += 50 * multiplier else: gained_score -= 50 * multiplier else: if bid <= tricks: overtricks = tricks - bid gained_score += 10 * bid + overtricks else: gained_score -= 10 * bid # If there were no nills on this team, carry on normally else: bid = self.bids.get_team_bid(team_id)[0] tricks = trick_count[player_1_id] + trick_count[player_2_id] if bid <= tricks: overtricks = tricks - bid gained_score += 10 * bid + overtricks else: gained_score -= 10 * bid # Lastly, check for sandbagging if (self.score[team_id] % 10) + (gained_score % 10) >= 10: gained_score -= 100 self.score.add_score(gained_score, team_id) def play_game(self): """""Simulate one game of Spades with the given players.""" assert len(self.players) == 4 self.score = Score() self.dealer = 0 # Give the players the starting score for i in range(4): self.players[i].announce_score(self.score.make_copy(i)) # Play rounds until one side wins while -self.playing_to < self.score[0] < self.playing_to and -self.playing_to < self.score[1] < self.playing_to: self.play_round() return self.score
class GameManager: def __init__(self, players=[IPlayer()] * 4, playing_to=500): self.players = players self.playing_to = playing_to self.score = Score( playing_to=playing_to ) # Players 0 and 2 form team 0, players 1 and 3 are team 1 self.hands = {} self.dealer = 0 self.bids = Bids() def deal_deck(self): """ Shuffle the deck and deal 13 cards to each player. Note that for Blind Nill purposes, the handing out of cards happens during the bidding phase. """ deck = [] for suit_id in range(4): for number_id in range(13): deck.append(card.Card(suit_id, number_id)) random.shuffle(deck) for i in range(4): hand = deck[13 * i:13 * (i + 1)] self.hands[i] = hand self.dealer = (self.dealer + 1) % 4 def get_bids(self): """"Get the bids of all players in order.""" self.bids = Bids() blind_accepted = False for i in range(4): # The value of 'dealer' will have been incremented at the end of the deal # Hence, it's current value is the player who should start bidding active_player_id = (self.dealer + i) % 4 # First, we have to check if a Blind Nill bid is allowed, and if so, offer the option if not blind_accepted and self.score.can_blind(active_player_id): if self.players[active_player_id].offer_blind_nill( self.bids.make_copy(active_player_id)): blind_accepted = True self.bids.add_bid(_BLIND_NILL_CHARACTER, active_player_id) self.players[active_player_id].give_hand( deepcopy(self.hands[active_player_id])) continue # Hand out the cards to the player and ask for a bid self.players[active_player_id].give_hand( deepcopy(self.hands[active_player_id])) player_bid = self.players[active_player_id].make_bid( self.bids.make_copy(active_player_id)) # Make sure the bid is valid: between 0 and 13, and the sum with the teammate's bid does not exceed 13 try: assert 0 <= player_bid <= 13 teammate_id = (active_player_id + 2) % 4 if teammate_id in self.bids and ( self.bids[teammate_id] != "N" and self.bids[teammate_id] != "B"): assert self.bids[teammate_id] + player_bid <= 13 except (AssertionError, TypeError): if 'teammate_id' in locals(): teammate_id = locals()['teammate_id'] raise exceptions.BidError(active_player_id, player_bid, self.bids[teammate_id]) raise exceptions.BidError(active_player_id, player_bid) self.bids.add_bid(player_bid, active_player_id) # When all bids have been made, inform all players about them for i, player in enumerate(self.players): player.announce_bids(self.bids.make_copy(i)) def handle_card_exchange(self): """"Exchanges 2 cards between the players of the team running a Blind Nill.""" assert self.bids.get_blinder_id() is not None blinder_id = self.bids.get_blinder_id() # Step 1: Get 2 cards from the person running the Blind Nill and give them to the teammate # Step 2: Get 2 cards from the teammate and give them to the person running the Blind Nill for i in [0, 2]: giver_id = (blinder_id + i) % 4 receiver_id = (giver_id + 2) % 4 offered_cards = None try: offered_cards = deepcopy( self.players[giver_id].request_blind_nill_cards()) # As always, don't trust the players, and check all conditions assert len(offered_cards) == 2 for offered_card in offered_cards: assert offered_card in self.hands[giver_id] self.hands[giver_id].remove(offered_card) except TypeError: raise exceptions.CardSwapError( giver_id, offered_cards, "Expected iterable containing 2 Card objects, player {0} provided {1} instead" .format(giver_id, offered_cards)) except AssertionError: if len(offered_cards) == 2: raise exceptions.CardSwapError( giver_id, offered_cards, "Player {0} handed invalid cards for card swap: {1}". format(giver_id, offered_cards)) raise exceptions.CardSwapError( giver_id, offered_cards, "Expected 2 Card objects, player {0} provided {1} instead". format(giver_id, offered_cards)) self.players[receiver_id].receive_blind_nill_cards( deepcopy(offered_cards)) self.hands[receiver_id] += offered_cards def get_trick(self, starting_player, spades_broken): """"Play a trick by getting a card from each player in order.""" current_trick = Trick() for i in range(4): player_id = (starting_player + i) % 4 card_played = self.players[player_id].play_card( current_trick.make_copy(player_id), self.get_valid_cards(player_id, current_trick, spades_broken)) try: assert self.verify_card_validity(card_played, player_id, current_trick, spades_broken) except AssertionError: raise exceptions.CardError(player_id, card_played) current_trick.add_card(card_played, player_id) self.hands[player_id].remove(card_played) return current_trick def verify_card_validity(self, played_card, player_id, trick, spades_broken): """"Verify that an offered card is valid to play.""" try: # First off, a card can only be played if the player actually has it assert played_card in self.hands[player_id] # Secondly, check if the card is of the right suit # If the player starts the trick or matches the suit, all is fine if trick.suit is not None and played_card.suit != trick.suit: for hand_card in self.hands[player_id]: assert hand_card.suit != trick.suit # Thirdly, a player may only start a trick with a spade if a spade has been played before, # or if the player only has spades left in his hand if trick.suit is None and played_card.suit == "S" and not spades_broken: for hand_card in self.hands[player_id]: assert hand_card.suit == "S" except AssertionError: return False return True def get_valid_cards(self, player_id, trick, spades_broken): """"Generate a list of all cards in a player's hand that are valid to play for this trick.""" valid_cards = [] for hand_card in self.hands[player_id]: if self.verify_card_validity(hand_card, player_id, trick, spades_broken): valid_cards.append(hand_card) return deepcopy(valid_cards) def play_round(self): """"Play a round, consisting of 13 tricks.""" # Set up the round spades_broken = False self.deal_deck() starting_player = self.dealer self.get_bids() trick_count = {0: 0, 1: 0, 2: 0, 3: 0} if self.bids.get_blinder_id() is not None: self.handle_card_exchange() # Play the round for i in range(13): current_trick = self.get_trick(starting_player, spades_broken) if current_trick.won_by_spade: spades_broken = True starting_player = current_trick.get_winner() trick_count[starting_player] += 1 # Inform all players of the final result of the trick for player_id, player in enumerate(self.players): player.announce_trick(current_trick.make_copy(player_id)) # Handle the scoring for i in [0, 1]: self.award_team_score(trick_count, i) # Inform all players about the new score for i, player in enumerate(self.players): player.announce_score(self.score.make_copy(i)) def award_team_score(self, trick_count, team_id): """"Given the bids and a resulting trick count, decide the score for a team.""" assert team_id == 0 or team_id == 1 gained_score = 0 player_1_id = 0 + team_id player_2_id = 2 + team_id # First, handle the situation of a player nilling if self.bids.team_has_nill(team_id): for player_id in [player_1_id, player_2_id]: bid = self.bids[player_id] tricks = trick_count[player_id] if bid == "N" or bid == "B": multiplier = 1 + int(bid == "B") if tricks == 0: gained_score += 50 * multiplier else: gained_score -= 50 * multiplier else: if bid <= tricks: overtricks = tricks - bid gained_score += 10 * bid + overtricks else: gained_score -= 10 * bid # If there were no nills on this team, carry on normally else: bid = self.bids.get_team_bid(team_id)[0] tricks = trick_count[player_1_id] + trick_count[player_2_id] if bid <= tricks: overtricks = tricks - bid gained_score += 10 * bid + overtricks else: gained_score -= 10 * bid # Lastly, check for sandbagging if (self.score[team_id] % 10) + (gained_score % 10) >= 10: gained_score -= 100 self.score.add_score(gained_score, team_id) def play_game(self): """"" Simulate one game of Spades with the given players. return: A Score object containing the resulting score of the match """ try: assert len(self.players) == 4 for player in self.players: assert isinstance(player, IPlayer) except AssertionError: raise exceptions.PlayerCountError(self.players) self.score = Score(playing_to=self.playing_to) self.dealer = 0 # Give the players the starting score for i in range(4): self.players[i].announce_score(self.score.make_copy(i)) # Play rounds until one side wins or loses while -self.playing_to < self.score[ 0] < self.playing_to and -self.playing_to < self.score[ 1] < self.playing_to: self.play_round() return self.score
def new_bid(): resp = helpers.get_response(request) loginmanager.verify_token(resp) newbid = Bids().new(resp) newbid.save() return jsonify({'status':'New bid ok', 'bid':newbid._to_json()}), 200
class FreelanceJobs(db.Expando, MyConstants, ErrorCodes): clsJob = Job() # Class to read and store freelance jobs to the data store and also to perform related tasks on the # Job clsBid = Bids() # Class to read and store freelance jobs Bids to the data store # The Person Class will be accessed using the DataType module clsWallet = Wallet() # Class to read and store Account Information for freelancers # All the temporary variables must be holding the correct values # All The variables within clsjob must be holding correct values also def createFreelanceJob(self): pass def readJob(self): try: if self.clsJob.isValid(): return self.clsJob else: return self._JobIsInvalid except: return self._generalError #write job will write all the temporary values back to datastore #TODO - CREATE FUNCTIONS TO ACCEPT INPUT FOR SUB CLASSES SUCH AS OWNER COMPANIES AND OWNER FREELANCERS #TODO- FOR JOBS THE FUNC #TODO- WILL BE CALLED BY WRITE JOB IN ORDER TO COMPLETE THE OVERALL OPERATION FOR WRITING A JOB #TODO- NOTE THAT THE SUBFUNCTIONS TO WRITE DATA WITHIN A SUBCLASS ARE CONTAINED WITHIN SUCH A SUB CLASS def writeJob(self, clsinput): try: Guser = users.get_current_user() if Guser: if (Guser.user_id() == clsinput.jobOwner()) or (users.is_current_user_admin()): if clsinput.isValid(): self.clsJob.writeJobOwner(clsinput.readJobOwner()) self.clsJob.writeEmployerCompany(clsinput.readEmployerCompany()) self.clsJob.writeCompanyOwner(clsinput.readCompanyOwner()) self.clsJob.writeDateTimeEndBidorRemove(clsinput.readDateTimeEndBidorRemove()) self.clsJob.writeDateTimeOfBidsDisplay(clsinput.readDateTimeOfBidsDisplay()) self.clsJob.writeJobBudgetSalary(clsinput.readJobBudgetSalary()) self.clsJob.writeJobDefinition(clsinput.readJobDefinition()) self.clsJob.writeJobKind(clsinput.readJobKind()) self.clsJob.writeJobType(clsinput.readJobType()) self.clsJob.writeNotes(clsinput.readNotes()) self.clsJob.writeRequiredEduQualifications(clsinput.readRequiredEduQualifications()) self.clsJob.writeSkillRequired(clsinput.readSkillsRequired()) self.clsJob.writestrJobTitle(clsinput.readstrJobTitle()) if not(self.clsJob.readBidsActivated() == self._generalError): self.clsjob.BidsActivated = clsinput.readBidsActivated() return True else: return False else: return False else: return self._UserNotAuthorised else: return self._userNotLoggedin except: return self._generalError def saveJob(self): try: Guser = users.get_current_user() if Guser: if (Guser.user_id() == self.clsJob.strOwnerReference) or (users.is_current_user_admin()): if self.clsJob.isValid(): self.clsJob._jobPkey = self.clsJob.put() return self.clsJob._jobPkey else: return self.undefined else: return self._UserNotAuthorised else: return self._userNotLoggedin except: return self._generalError def retrieveJobByPkey(self): try: if not(self.clsJob._jobPkey == self.undefined): temp = Job.get(self.clsJob._jobPkey) if temp.isValid(): return temp else: return self.undefined else: return self._pkeyNotSet except: return self._generalError def retrieveJobsByJobOwner(self, strinput): try: if strinput.isalnum(): findquery = db.Query(Job).filter('strOwnerReference = ', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: logging.info('FOUND JOBS') return results else: logging.info('FOUND JOBS') return self._JobsNotFound else: logging.info('NOT FOUND JOBS') return self._pkeyNotSet except: return self._generalError def retrieveJobsByCompanyOwner(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput.isalnum(): findquery = db.Query(Job).filter('clsCompanyOwner =', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self._pkeyNotSet except: return self._generalError def retrieveJobsByEmployerCompany(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput.isalnum(): findquery = db.Query(Job).filter('clsEmployerCompany =', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self._pkeyNotSet except: return self._generalError def retrieveJobsByJobTitle(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput.isalnum() or strinput.isalpha(): findquery = db.Query(Job).filter('strJobTitle =', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self.undefined except: return self._generalError def retrieveJobsByJobType(self, strinput): try: logging.info('RETIRVE FREELANCE JOBS CALLED') strinput = str(strinput) strinput = strinput.strip() if strinput in self.clsJob._lstJobTypes: findquery = db.Query(Job).filter('strJobType =', strinput).order('-BidsActivated').order('-DateTimeSubmitted') results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self._pkeyNotSet except: return self._generalError def retrieveJobsByJobKind(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput in self.clsJob._lstJobKinds: findquery = db.Query(Job).filter('strJobKind =', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self._pkeyNotSet except: return self._generalError def retrieveJobsByJobBudget(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput in self.clsJob._lstFreelanceJobBudget: findquery = db.Query(Job).filter('strFreelanceJobBudget =', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self._pkeyNotSet except: return self._generalError def retrieveJobsBySkillsPkey(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput.isalnum(): findquery = db.Query(Job).filter('clsSkillsRequired =', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self._pkeyNotSet except: return self._generalError def retrieveJobsByEduQualificationsPkey(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput.isalnum(): findquery = db.Query(Job).filter('clsRequiredEduQualifications =', strinput) results = findquery.fetch(limit=self._maxQResults) if len(results) > 0: return results else: return self._JobsNotFound else: return self._pkeyNotSet except: return self._generalError def getJobByBid(self): pass # Given The reference Number of the freelance job search for all the jobs and return only those jobs which are # freelance jobs and owned by a certain user def GetFreelanceJobsByReference(self, strinput): try: strinput = str(strinput) strinput = strinput.strip() if strinput.isalpha() or strinput.isalnum(): findrequest = db.Query(Job).filter('strOwnerReference =', strinput) findrequest = findrequest.filter('strJobType =', self.clsJob._lstJobTypes[2]).order('DateTimeSubmitted') results = findrequest.fetch(limit=self._maxQResults) logging.info('NUMBER OF PERSONAL JOBS RETURNED :' + str(len(results))) if len(results) > 0: # All the jobs are returned # find freelance jobs from the list and return only freelance jobs return results else: return self._JobsNotFound else: return self._referenceDoNotExist except: return self._generalError