import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
     * A simple endpoint method that takes a name and says Hi back
     */
   /* @ApiMethod(name = "sayHi")
    public MyBean sayHi(@Named("name") String name) {
        MyBean response = new MyBean();
        response.setData("Hi, " + name);

        return response;
    }*/

    @ApiMethod(name = "insertUser")
    public Users insertUsers(Users users) throws ConflictException {
//If if is not null, then check if it exists. If yes, throw an Exception
//that it is already present
        if (users.getId() != null) {
            if (findRecord(users.getId()) != null) {
                throw new ConflictException("User id already exists,please login");
            }
        }

        ofy().save().entity(users).now();
        return users;
    }
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
@Test(expected = ConflictException.class)
public void testRegistrationFailure_NoSeatsAvailable() throws Exception {
    DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");
    Date startDate = dateFormat.parse("03/25/2014");
    Date endDate = dateFormat.parse("03/26/2014");
    List<String> topics = new ArrayList<>();
    topics.add("Google");
    topics.add("Cloud");
    topics.add("Platform");
    // Create a conference as the remaining seats is zero.
    ConferenceForm conferenceForm = new ConferenceForm(
            NAME, DESCRIPTION, topics, CITY, startDate, endDate, 0);
    Conference conference = conferenceApi.createConference(user, conferenceForm);
    conferenceApi.registerForConference(
            user, conference.getWebsafeKey()).getResult();
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
@Test(expected = ConflictException.class)
public void testRegistrationFailure_AlreadyRegisteredForTheSameConference() throws Exception {
    DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");
    Date startDate = dateFormat.parse("03/25/2014");
    Date endDate = dateFormat.parse("03/26/2014");
    List<String> topics = new ArrayList<>();
    topics.add("Google");
    topics.add("Cloud");
    topics.add("Platform");
    ConferenceForm conferenceForm = new ConferenceForm(
            NAME, DESCRIPTION, topics, CITY, startDate, endDate, CAP);
    Conference conference = conferenceApi.createConference(user, conferenceForm);
    // Registration
    Boolean result = conferenceApi.registerForConference(
            user, conference.getWebsafeKey()).getResult();
    conference = conferenceApi.getConference(conference.getWebsafeKey());
    Profile profile = ofy().load().key(Key.create(Profile.class, user.getUserId())).now();
    assertTrue("The first registration should succeed.", result);
    assertEquals(CAP - 1, conference.getSeatsAvailable());
    assertTrue("Profile should have the conferenceId in conferenceIdsToAttend.",
            profile.getConferenceKeysToAttend().contains(conference.getWebsafeKey()));

    // The user has already registered for the conference. This should throw an ForbiddenException.
    conferenceApi.registerForConference(
            user, conference.getWebsafeKey()).getResult();
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Declines an invitation.
 *
 * @param gameId the game id this invitation is for.
 * @param invitationId the invitation id.
 * @throws NotFoundException if there is no record for this gameId and invitationId.
 * @throws ConflictException if the invitation state has changed and the invitation cannot be
 *         declined.
 */
public void declineInvitation(long gameId, long invitationId)
    throws NotFoundException, ConflictException {
  InvitationEntity invitation = get(gameId, invitationId);

  if (invitation == null) {
    throw new NotFoundException("Invitation record not found.");
  }

  if (!invitation.decline()) {
    throw new ConflictException(
        "Unable to decline the invitation because it has already been accepted "
        + "or is no longer valid.");
  }

  dataStore.put(invitation.getEntity());
  cacheInvitationStatus(gameId, invitationId, InvitationEntity.Status.DECLINED);
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Cancels an invitation.
 *
 * @param gameId the game id this invitation is for.
 * @param invitationId the invitation id.
 * @throws NotFoundException if there is no record for this gameId and invitationId.
 * @throws ConflictException if the invitation state has changed and the invitation cannot be
 *         cancelled.
 */
public void cancelInvitation(long gameId, long invitationId)
    throws NotFoundException, ConflictException {
  InvitationEntity invitation = get(gameId, invitationId);

  if (invitation == null) {
    throw new NotFoundException("Invitation record not found.");
  }

  if (!invitation.cancel()) {
    throw new ConflictException(
        "Unable to decline the invitation because it has already been accepted.");
  }

  dataStore.put(invitation.getEntity());
  cacheInvitationStatus(gameId, invitationId, InvitationEntity.Status.CANCELED);
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
@ApiMethod(
        name = "checkUser",
        path = "checkUser",
        httpMethod = ApiMethod.HttpMethod.POST)
public Users checkUser(@Named ("email") String email) throws ConflictException {
   /* List<Users> lusers=ofy().load().type(Users.class).filter("email","[email protected]").list();
    for(Users users:lusers){
        ofy().delete().type(Users.class).id(users.getId()).now();
    }*/

    return ofy().load().type(Users.class).filter("email",email).first().now();

}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
private TxResult(Throwable exception) {
    if (exception instanceof NotFoundException ||
            exception instanceof ForbiddenException ||
            exception instanceof ConflictException) {
        this.exception = exception;
    } else {
        throw new IllegalArgumentException("Exception not supported.");
    }
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
private ResultType getResult() throws NotFoundException, ForbiddenException, ConflictException {
    if (exception instanceof NotFoundException) {
        throw (NotFoundException) exception;
    }
    if (exception instanceof ForbiddenException) {
        throw (ForbiddenException) exception;
    }
    if (exception instanceof ConflictException) {
        throw (ConflictException) exception;
    }
    return result;
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Unregister from the specified Conference.
 *
 * @param user An user who invokes this method, null when the user is not signed in.
 * @param websafeConferenceKey The String representation of the Conference Key to unregister
 *                             from.
 * @return Boolean true when success, otherwise false.
 * @throws UnauthorizedException when the user is not signed in.
 * @throws NotFoundException when there is no Conference with the given conferenceId.
 */
@ApiMethod(
        name = "unregisterFromConference",
        path = "conference/{websafeConferenceKey}/registration",
        httpMethod = HttpMethod.DELETE
)
public WrappedBoolean unregisterFromConference(final User user,
                                        @Named("websafeConferenceKey")
                                        final String websafeConferenceKey)
        throws UnauthorizedException, NotFoundException, ForbiddenException, ConflictException {
    // If not signed in, throw a 401 error.
    if (user == null) {
        throw new UnauthorizedException("Authorization required");
    }
    final String userId = getUserId(user);
    TxResult<Boolean> result = ofy().transact(new Work<TxResult<Boolean>>() {
        @Override
        public TxResult<Boolean> run() {
            Key<Conference> conferenceKey = Key.create(websafeConferenceKey);
            Conference conference = ofy().load().key(conferenceKey).now();
            // 404 when there is no Conference with the given conferenceId.
            if (conference == null) {
                return new TxResult<>(new NotFoundException(
                        "No Conference found with key: " + websafeConferenceKey));
            }
            // Un-registering from the Conference.
            Profile profile = getProfileFromUser(user, userId);
            if (profile.getConferenceKeysToAttend().contains(websafeConferenceKey)) {
                profile.unregisterFromConference(websafeConferenceKey);
                conference.giveBackSeats(1);
                ofy().save().entities(profile, conference).now();
                return new TxResult<>(true);
            } else {
                return new TxResult<>(false);
            }
        }
    });
    // NotFoundException is actually thrown here.
    return new WrappedBoolean(result.getResult());
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Accepts an invitation.
 *
 * @param gameId the game id this invitation is for.
 * @param invitationId the invitation id.
 * @throws NotFoundException if there is no record for this gameId and invitationId.
 * @throws ConflictException if the invitation state has changed and the invitation cannot be
 *         accepted.
 */
public void acceptInvitation(long gameId, long invitationId)
    throws NotFoundException, ConflictException {
  InvitationEntity invitation = get(gameId, invitationId);

  if (invitation == null) {
    throw new NotFoundException("Invitation record not found.");
  }

  if (!invitation.accept()) {
    throw new ConflictException(
        "Unable to accept the invitation because it has already been declined "
        + "or is no longer valid.");
  }

  Transaction transaction = dataStore.beginTransaction();

  try {
    GamePlayEntity inviteePlayer =
        new GamePlayEntity(invitation.getInviteeKey(), invitation.getParentKey());
    GamePlayEntity senderPlayer =
        new GamePlayEntity(invitation.getSenderKey(), invitation.getParentKey());

    dataStore.put(transaction, senderPlayer.getEntity());
    dataStore.put(transaction, inviteePlayer.getEntity());
    dataStore.put(transaction, invitation.getEntity());

    transaction.commit();

    cacheInvitationStatus(gameId, invitationId, InvitationEntity.Status.ACCEPTED);
  } finally {
    if (transaction.isActive()) {
      transaction.rollback();
    }
  }
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
@ApiMethod(
        httpMethod = "POST",
        path = "register"
        )
public void register(RegisterAttendee command) throws ConflictException, NotFoundException, BadRequestException {
	processCommand(command);
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
@ApiMethod(
        httpMethod = "POST",
        path = "changename"
        )
public void changeName(ChangeAttendeeName command) throws ConflictException, NotFoundException, BadRequestException  {
    processCommand(command);
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
@ApiMethod(
        httpMethod = "POST",
        path = "changeemail"
        )
public void changeEmail(ChangeAttendeeEmail command) throws ConflictException, NotFoundException, BadRequestException  {
    processCommand(command);
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
@ApiMethod(
        httpMethod = "POST",
        path = "confirmchangeemail"
        )
public void confirmChangeEmail(ConfirmChangeEmail command) throws ConflictException, NotFoundException, BadRequestException  {
    processCommand(command);
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Unregister from the specified Conference.
 *
 * @param user An user who invokes this method, null when the user is not signed in.
 * @param websafeConferenceKey The String representation of the Conference Key to unregister
 *                             from.
 * @return Boolean true when success, otherwise false.
 * @throws UnauthorizedException when the user is not signed in.
 * @throws NotFoundException when there is no Conference with the given conferenceId.
 */
@ApiMethod(
        name = "unregisterFromConference",
        path = "conference/{websafeConferenceKey}/registration",
        httpMethod = HttpMethod.DELETE
)
public WrappedBoolean unregisterFromConference(final User user,
                                        @Named("websafeConferenceKey")
                                        final String websafeConferenceKey)
        throws UnauthorizedException, NotFoundException, ForbiddenException, ConflictException {
    // If not signed in, throw a 401 error.
    if (user == null) {
        throw new UnauthorizedException("Authorization required");
    }

    WrappedBoolean result = ofy().transact(new Work<WrappedBoolean>() {
        @Override
        public WrappedBoolean run() {
            Key<Conference> conferenceKey = Key.create(websafeConferenceKey);
            Conference conference = ofy().load().key(conferenceKey).now();
            // 404 when there is no Conference with the given conferenceId.
            if (conference == null) {
                return new  WrappedBoolean(false,
                        "No Conference found with key: " + websafeConferenceKey);
            }

            // Un-registering from the Conference.
            Profile profile = getProfileFromUser(user);
            if (profile.getConferenceKeysToAttend().contains(websafeConferenceKey)) {
                profile.unregisterFromConference(websafeConferenceKey);
                conference.giveBackSeats(1);
                ofy().save().entities(profile, conference).now();
                return new WrappedBoolean(true);
            } else {
                return new WrappedBoolean(false, "You are not registered for this conference");
            }
        }
    });
    // if result is false
    if (!result.getResult()) {
        if (result.getReason().contains("No Conference found with key")) {
            throw new NotFoundException (result.getReason());
        }
        else {
            throw new ForbiddenException(result.getReason());
        }
    }
    // NotFoundException is actually thrown here.
    return new WrappedBoolean(result.getResult());
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Updates the existing Conference with the given conferenceId.
 *
 * @param user A user who invokes this method, null when the user is not signed in.
 * @param conferenceForm A ConferenceForm object representing user's inputs.
 * @param websafeConferenceKey The String representation of the Conference key.
 * @return Updated Conference object.
 * @throws UnauthorizedException when the user is not signed in.
 * @throws NotFoundException when there is no Conference with the given conferenceId.
 * @throws ForbiddenException when the user is not the owner of the Conference.
 */
@ApiMethod(
        name = "updateConference",
        path = "conference/{websafeConferenceKey}",
        httpMethod = HttpMethod.PUT
)
public Conference updateConference(final User user, final ConferenceForm conferenceForm,
                                   @Named("websafeConferenceKey")
                                   final String websafeConferenceKey)
        throws UnauthorizedException, NotFoundException, ForbiddenException, ConflictException {
    // If not signed in, throw a 401 error.
    if (user == null) {
        throw new UnauthorizedException("Authorization required");
    }
    final String userId = getUserId(user);
    // Update the conference with the conferenceForm sent from the client.
    // Need a transaction because we need to safely preserve the number of allocated seats.
    TxResult<Conference> result = ofy().transact(new Work<TxResult<Conference>>() {
        @Override
        public TxResult<Conference> run() {
            // If there is no Conference with the id, throw a 404 error.
            Key<Conference> conferenceKey = Key.create(websafeConferenceKey);
            Conference conference = ofy().load().key(conferenceKey).now();
            if (conference == null) {
                return new TxResult<>(
                        new NotFoundException("No Conference found with the key: "
                                + websafeConferenceKey));
            }
            // If the user is not the owner, throw a 403 error.
            Profile profile = ofy().load().key(Key.create(Profile.class, userId)).now();
            if (profile == null ||
                    !conference.getOrganizerUserId().equals(userId)) {
                return new TxResult<>(
                        new ForbiddenException("Only the owner can update the conference."));
            }
            conference.updateWithConferenceForm(conferenceForm);
            ofy().save().entity(conference).now();
            return new TxResult<>(conference);
        }
    });
    // NotFoundException or ForbiddenException is actually thrown here.
    return result.getResult();
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Registers to the specified Conference.
 *
 * @param user An user who invokes this method, null when the user is not signed in.
 * @param websafeConferenceKey The String representation of the Conference Key.
 * @return Boolean true when success, otherwise false
 * @throws UnauthorizedException when the user is not signed in.
 * @throws NotFoundException when there is no Conference with the given conferenceId.
 */
@ApiMethod(
        name = "registerForConference",
        path = "conference/{websafeConferenceKey}/registration",
        httpMethod = HttpMethod.POST
)
public WrappedBoolean registerForConference(final User user,
                                     @Named("websafeConferenceKey")
                                     final String websafeConferenceKey)
    throws UnauthorizedException, NotFoundException, ForbiddenException, ConflictException {
    // If not signed in, throw a 401 error.
    if (user == null) {
        throw new UnauthorizedException("Authorization required");
    }
    final String userId = getUserId(user);
    TxResult<Boolean> result = ofy().transact(new Work<TxResult<Boolean>>() {
        @Override
        public TxResult<Boolean> run() {
            Key<Conference> conferenceKey = Key.create(websafeConferenceKey);
            Conference conference = ofy().load().key(conferenceKey).now();
            // 404 when there is no Conference with the given conferenceId.
            if (conference == null) {
                return new TxResult<>(new NotFoundException(
                        "No Conference found with key: " + websafeConferenceKey));
            }
            // Registration happens here.
            Profile profile = getProfileFromUser(user, userId);
            if (profile.getConferenceKeysToAttend().contains(websafeConferenceKey)) {
                return new TxResult<>(new ConflictException("You have already registered for this conference"));
            } else if (conference.getSeatsAvailable() <= 0) {
                return new TxResult<>(new ConflictException("There are no seats available."));
            } else {
                profile.addToConferenceKeysToAttend(websafeConferenceKey);
                conference.bookSeats(1);
                ofy().save().entities(profile, conference).now();
                return new TxResult<>(true);
            }
        }
    });
    // NotFoundException is actually thrown here.
    return new WrappedBoolean(result.getResult());
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Register to attend the specified Conference.
 *
 * @param user An user who invokes this method, null when the user is not signed in.
 * @param websafeConferenceKey The String representation of the Conference Key.
 * @return Boolean true when success, otherwise false
 * @throws UnauthorizedException when the user is not signed in.
 * @throws NotFoundException when there is no Conference with the given conferenceId.
 */
@ApiMethod(
        name = "registerForConference",
        path = "conference/{websafeConferenceKey}/registration",
        httpMethod = HttpMethod.POST
)
public WrappedBoolean registerForConference(final User user,
        @Named("websafeConferenceKey") final String websafeConferenceKey)
        throws UnauthorizedException, NotFoundException,
        ForbiddenException, ConflictException {
    if (user == null) {
        throw new UnauthorizedException("Authorization required");
    }

    // Start transaction
    WrappedBoolean result = ofy().transact(new Work<WrappedBoolean>() {
        @Override
    	public WrappedBoolean run() {
            try {
         Key<Conference> conferenceKey = Key.create(websafeConferenceKey);
         Conference conference = ofy().load().key(conferenceKey).now();

         if (conference == null) {
             return new WrappedBoolean (false,
                     "No Conference found with key: "
                             + websafeConferenceKey);
         }
	
         Profile profile = getProfileFromUser(user);
	
         if (profile.getConferenceKeysToAttend().contains(
                 websafeConferenceKey)) {
             return new WrappedBoolean (false, "Already registered");
         } else if (conference.getSeatsAvailable() <= 0) {
             return new WrappedBoolean (false, "No seats available");
         } else {
             profile.addToConferenceKeysToAttend(websafeConferenceKey);
             conference.bookSeats(1);
             ofy().save().entities(profile, conference).now();
             
             return new WrappedBoolean(true, "Registration successful");
         }
	
         }
         catch (Exception e) {
             return new WrappedBoolean(false, "Unknown exception");
         }
        }
    });
    if (!result.getResult()) {
        if (result.getReason().contains("No Conference found with key")) {
            throw new NotFoundException (result.getReason());
        }
        else if (result.getReason() == "Already registered") {
            throw new ConflictException("You have already registered");
        }
        else if (result.getReason() == "No seats available") {
            throw new ConflictException("There are no seats available");
        }
        else {
            throw new ForbiddenException("Unknown exception");
        }
    }
    return result;
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Unregister from the specified Conference.
 *
 * @param user An user who invokes this method, null when the user is not signed in.
 * @param websafeConferenceKey The String representation of the Conference Key to unregister
 *                             from.
 * @return Boolean true when success, otherwise false.
 * @throws UnauthorizedException when the user is not signed in.
 * @throws NotFoundException when there is no Conference with the given conferenceId.
 */
@ApiMethod(
        name = "unregisterFromConference",
        path = "conference/{websafeConferenceKey}/registration",
        httpMethod = HttpMethod.DELETE
)
public WrappedBoolean unregisterFromConference(final User user,
                                        @Named("websafeConferenceKey")
                                        final String websafeConferenceKey)
        throws UnauthorizedException, NotFoundException, ForbiddenException, ConflictException {
    if (user == null) {
        throw new UnauthorizedException("Authorization required");
    }

    WrappedBoolean result = ofy().transact(new Work<WrappedBoolean>() {
        @Override
        public WrappedBoolean run() {
            Key<Conference> conferenceKey = Key.create(websafeConferenceKey);
            Conference conference = ofy().load().key(conferenceKey).now();
            if (conference == null) {
                return new  WrappedBoolean(false,
                        "No Conference found with key: " + websafeConferenceKey);
            }

            Profile profile = getProfileFromUser(user);
            if (profile.getConferenceKeysToAttend().contains(websafeConferenceKey)) {
                profile.unregisterFromConference(websafeConferenceKey);
                conference.giveBackSeats(1);
                ofy().save().entities(profile, conference).now();
                return new WrappedBoolean(true);
            } else {
                return new WrappedBoolean(false, "You are not registered for this conference");
            }
        }
    });
    if (!result.getResult()) {
        if (result.getReason().contains("No Conference found with key")) {
            throw new NotFoundException (result.getReason());
        }
        else {
            throw new ForbiddenException(result.getReason());
        }
    }
    return new WrappedBoolean(result.getResult());
}
 

import com.google.api.server.spi.response.ConflictException; //导入依赖的package包/类
/**
 * Add the specified session to wishlist.
 *
 * @param user An user who invokes this method, null when the user is not signed in.
 * @param websafeSessionKey The String representation of the Session Key.
 * @return Boolean true when success, otherwise false
 * @throws UnauthorizedException when the user is not signed in.
 * @throws NotFoundException when there is no Session with the given sessionId.
 */
@ApiMethod(
        name = "addSessionToWishlist",
        path = "conference/session/{websafeSessionKey}/wishlist",
        httpMethod = HttpMethod.POST
)
public WrappedBoolean addSessionToWishlist(final User user,
        @Named("websafeSessionKey") final String websafeSessionKey)
        throws UnauthorizedException, NotFoundException,
        ForbiddenException, ConflictException {
    if (user == null) {
        throw new UnauthorizedException("Authorization required");
    }

    // Start transaction
    WrappedBoolean result = ofy().transact(new Work<WrappedBoolean>() {
        @Override
        public WrappedBoolean run() {
            try {
            Key<Session> sessionKey = Key.create(websafeSessionKey);
            Session session = ofy().load().key(sessionKey).now();

            if (session == null) {
                return new WrappedBoolean (false,
                        "No session found with key: "
                                + websafeSessionKey);
            }

            Profile profile = getProfileFromUser(user);

            if (profile.getSessionKeysInWishlist().contains(
                    websafeSessionKey)) {
                return new WrappedBoolean (false, "Already in the wishlist");
            } else {
                profile.addToSessionKeysInWishlist(websafeSessionKey);
                ofy().save().entity(profile).now();
                
                return new WrappedBoolean(true, "Successfully added to your wishlist");
            }

            }
            catch (Exception e) {
                return new WrappedBoolean(false, "Unknown exception");
            }
        }
    });
    if (!result.getResult()) {
        if (result.getReason().contains("No Session found with key")) {
            throw new NotFoundException (result.getReason());
        }
        else if (result.getReason() == "Already in the wishlist") {
            throw new ConflictException("You have already added to your wishlist");
        }
        else {
            throw new ForbiddenException("Unknown exception");
        }
    }
    return result;
}