public RequestEntity build() { return new RequestEntity(mId, mCreatedBy, mCreatedAt, mCreatedComment, mCreatedPictures, mCreatedVotes, mLatitude, mLongitude, mPickedUpBy, mPickedUpAt, mClosedBy, mClosedAt, mClosedComment, mClosedPictures, mClosedVotes, mLocation); } }
private RequestEntity addReverseGeocodedLocation(RequestEntity request) { String location = mReverseGeocoder.getFromLocation( request.getLatitude(), request.getLongitude(), Locale.getDefault()); if (location != null) { return RequestEntity.getBuilder(request).setLocation(location).build(); } else { return request; } }
private ContentValues requestEntityToContentValues(RequestEntity requestEntity) { ContentValues values = new ContentValues(); values.put(Requests.COL_REQUEST_ID, requestEntity.getId()); values.put(Requests.COL_CREATED_BY, requestEntity.getCreatedBy()); values.put(Requests.COL_CREATED_AT, requestEntity.getCreatedAt()); values.put(Requests.COL_CREATED_COMMENT, requestEntity.getCreatedComment()); values.put(Requests.COL_CREATED_PICTURES, StringUtils.listToCommaSeparatedString(requestEntity.getCreatedPictures())); values.put(Requests.COL_CREATED_VOTES, requestEntity.getCreatedVotes()); values.put(Requests.COL_LATITUDE, requestEntity.getLatitude()); values.put(Requests.COL_LONGITUDE, requestEntity.getLongitude()); values.put(Requests.COL_PICKED_UP_BY, requestEntity.getPickedUpBy()); values.put(Requests.COL_PICKED_UP_AT, requestEntity.getPickedUpAt()); values.put(Requests.COL_CLOSED_BY, requestEntity.getClosedBy()); values.put(Requests.COL_CLOSED_AT, requestEntity.getClosedAt()); values.put(Requests.COL_CLOSED_COMMENT, requestEntity.getClosedComment()); values.put(Requests.COL_CLOSED_PICTURES, StringUtils.listToCommaSeparatedString(requestEntity.getClosedPictures())); values.put(Requests.COL_CLOSED_VOTES, requestEntity.getClosedVotes()); values.put(Requests.COL_LOCATION, requestEntity.getLocation()); return values; }
public String getLatestActivityAt() { return IdcDateTimeUtils.getLatestDateTime(getCreatedAt(), getPickedUpAt(), getClosedAt()); }
private void setTexts() { if (mRequest.isClosed()) mTxtRequestStatus.setText(getRootView().getResources().getString(R.string.txt_closed_request_title)); else if (mRequest.isPickedUp()) mTxtRequestStatus.setText(getRootView().getResources().getString(R.string.txt_picked_up_request_title)); else mTxtRequestStatus.setText(getRootView().getResources().getString(R.string.txt_new_request_title)); mTxtCreatedAt.setText(mRequest.getCreatedAt()); mTxtCreatedVotes.setText(String.valueOf(mRequest.getCreatedVotes())); }
@Test public void applyUserActionToRequest_closeRequestUserActionOnPickedUpRequest_requestAffected() { // Arrange String userId = RequestEntityProvider.REQUEST_PICKED_UP_BY; String closedComment = "closed comment"; List<String> closedPictures = Arrays.asList("picture1", "picture2"); RequestEntity originalRequestEntity = RequestEntityProvider.getPickedUpRequestEntity(); UserActionEntity closeUserAction = mUserActionEntityFactory.newCloseRequest( originalRequestEntity.getId(), userId, closedComment, closedPictures); // Act RequestEntity resultRequestEntity = SUT.applyUserActionToRequest(closeUserAction, originalRequestEntity); // Assert assertThat(resultRequestEntity.getClosedBy(), is(userId)); assertThat(resultRequestEntity.getClosedAt(), is(DEFAULT_TIMESTAMP)); assertThat(resultRequestEntity.getClosedComment(), is(closedComment)); assertEquals(resultRequestEntity.getClosedPictures(), closedPictures); assertThat(resultRequestEntity.getClosedVotes(), is(0)); }
builder.addFormDataPart(Constants.FIELD_NAME_CREATED_COMMENT, request.getCreatedComment()); builder.addFormDataPart(Constants.FIELD_NAME_LATITUDE, String.valueOf(request.getLatitude())); builder.addFormDataPart(Constants.FIELD_NAME_LONGITUDE, String.valueOf(request.getLongitude())); builder.addFormDataPart(Constants.FIELD_NAME_CREATED_POLLUTION_LEVEL, "1"); // TODO: remove request.getCreatedPictures(), Constants.FIELD_NAME_CREATED_PICTURES ); mTempIdCacher.cacheTempIdMapping(requestId, updatedRequest.getId()); mEventBus.post(new RequestIdChangedEvent(requestId, updatedRequest.getId())); } else { throw new SyncFailedException("create new request call failed; response code: " + response.code());
public void addNewRequest(final RequestEntity newRequest) { mLogger.d(TAG, "addNewRequest(); request ID: " + newRequest.getId()); final CreateRequestUserActionEntity createRequestUserAction = new CreateRequestUserActionEntity( newRequest.getCreatedAt(), newRequest.getId(), newRequest.getCreatedBy()); mBackgroundThreadPoster.post(new Runnable() { @Override public void run() { // TODO: ensure atomicity of below actions using TransactionController mUserActionCacher.cacheUserAction(createRequestUserAction); mRequestsCacher.updateOrInsertAndNotify(newRequest); } }); }
private void refreshUsers() { if (mRequest == null) { // request's info hasn't been fetched yet - users info can't be refreshed return; } List<String> usersIds = new ArrayList<>(3); usersIds.add(mRequest.getCreatedBy()); String pickedUpBy = mRequest.getPickedUpBy(); String closedBy = mRequest.getClosedBy(); if (pickedUpBy != null && !pickedUpBy.isEmpty()) { usersIds.add(pickedUpBy); } if (closedBy != null && !closedBy.isEmpty()) { usersIds.add(closedBy); } mUsersManager.fetchUsersByIdAndNotify(usersIds, this); }
&& !requestEntity.isClosed()) { throw new IllegalArgumentException("cant vote for closed on non-closed request"); RequestEntity.RequestEntityBuilder requestEntityBuilder = RequestEntity.getBuilder(requestEntity); requestEntityBuilder.setCreatedVotes(requestEntity.getCreatedVotes() + 1); break; case VoteForRequestUserActionEntity.VOTE_DOWN_CREATED: requestEntityBuilder.setCreatedVotes(requestEntity.getCreatedVotes() - 1); break; case VoteForRequestUserActionEntity.VOTE_UP_CLOSED: requestEntityBuilder.setClosedVotes(requestEntity.getClosedVotes() + 1); break; case VoteForRequestUserActionEntity.VOTE_DOWN_CLOSED: requestEntityBuilder.setClosedVotes(requestEntity.getClosedVotes() - 1); break; default:
private RequestEntity closeRequest(CloseRequestUserActionEntity closeRequestUserAction, RequestEntity requestEntity) { if (requestEntity.getClosedBy() != null && !requestEntity.getClosedBy().isEmpty()) { throw new IllegalArgumentException("request already closed"); } if (requestEntity.getPickedUpBy() == null || requestEntity.getPickedUpBy().isEmpty()) { throw new IllegalArgumentException("request is not picked up"); } if (!requestEntity.getPickedUpBy().equals(closeRequestUserAction.getClosedByUserId())) { throw new IllegalArgumentException("closing user must be the same who picked up"); } return RequestEntity.getBuilder(requestEntity) .setClosedBy(closeRequestUserAction.getClosedByUserId()) .setClosedAt(String.valueOf(closeRequestUserAction.getDatetime())) .setClosedComment(closeRequestUserAction.getClosedComment()) .setClosedPictures(closeRequestUserAction.getClosedPictures()) .build(); }
RequestEntity initiallyNewRequest = RequestEntityProvider.getNewRequestEntity(); RequestEntity initiallyPickedUpRequest = RequestEntity .getBuilder(RequestEntityProvider.getPickedUpRequestEntity()) .setPickedUpBy(TEST_USER_ID) .build(); initiallyPickedUpRequest.getId(), TEST_USER_ID, "closed_comment", Arrays.asList("one", "two")); PickUpRequestUserActionEntity pickUpNew = mUserActionEntityFactory.newPickUpRequest(initiallyNewRequest.getId(), TEST_USER_ID); VoteForRequestUserActionEntity voteForClosed = mUserActionEntityFactory.newVoteUpForRequestClosed(initiallyClosedRequest.getId()); RequestEntity updatedInitiallyNewRequest = getRequestById(resultRequests, initiallyNewRequest.getId()); assertNotNull(updatedInitiallyNewRequest); assertRequestsEqual(updatedInitiallyNewRequest, RequestEntity.getBuilder(initiallyNewRequest) .setPickedUpBy(pickUpNew.getPickedUpByUserId()) .setPickedUpAt(pickUpNew.getPickedUpAt()) .build()); RequestEntity updatedInitiallyPickedUpRequest = getRequestById(resultRequests, initiallyPickedUpRequest.getId()); assertNotNull(updatedInitiallyPickedUpRequest); assertRequestsEqual(updatedInitiallyPickedUpRequest, RequestEntity.getBuilder(initiallyPickedUpRequest) .setClosedBy(closePickedUp.getClosedByUserId()) .setClosedAt(closePickedUp.getClosedAt()) RequestEntity updatedInitiallyClosedRequest = getRequestById(resultRequests, initiallyClosedRequest.getId()); assertNotNull(updatedInitiallyClosedRequest); assertRequestsEqual(updatedInitiallyClosedRequest, RequestEntity.getBuilder(initiallyClosedRequest) .setClosedVotes(initiallyClosedRequest.getClosedVotes() + 1)
@Test public void applyUserActionToRequest_voteUpForClosedUserAction_requestAffected() throws Exception { // Arrange RequestEntity requestEntity = RequestEntityProvider.getClosedRequestEntity(); UserActionEntity voteUpClosedEntity = mUserActionEntityFactory.newVoteUpForRequestClosed(requestEntity.getId()); // Act RequestEntity resultRequestEntity = SUT.applyUserActionToRequest(voteUpClosedEntity, requestEntity); // Assert assertThat(resultRequestEntity.getClosedVotes(), is(RequestEntityProvider.REQUEST_CLOSED_VOTES + 1)); }
private List<RequestEntity> applyUserActionsToRequests(List<RequestEntity> requests) { List<UserActionEntity> userActions = mUserActionsRetriever.getAllUserActions(); if (userActions.isEmpty() || requests.isEmpty()) return requests; Collections.sort(requests, mComparator); // sort in order to be able to use binary search List<RequestEntity> updatedRequests = new ArrayList<>(requests); RequestEntity updatedRequest; for (UserActionEntity userAction : userActions) { if (mUserActionsToRequestsApplier.isUserActionAffectingRequest(userAction)) { // find the request affected by user action, and if it is found - apply the action to it int affectedEntityPos = Collections.binarySearch( requests, RequestEntity.getBuilder().setId(userAction.getEntityId()).build(), mComparator); if (affectedEntityPos >= 0) { updatedRequest = mUserActionsToRequestsApplier.applyUserActionToRequest( userAction, requests.get(affectedEntityPos)); updatedRequests.set(affectedEntityPos, updatedRequest); } } } return updatedRequests; }
private RequestEntity pickUpRequest(@NonNull PickUpRequestUserActionEntity pickUpRequestUserAction, @NonNull RequestEntity requestEntity) { if (requestEntity.isPickedUp()) { throw new IllegalArgumentException("request already picked up"); } String pickedUpByUserId = pickUpRequestUserAction.getPickedUpByUserId(); return RequestEntity.getBuilder(requestEntity) .setPickedUpBy(pickedUpByUserId) .setPickedUpAt(String.valueOf(pickUpRequestUserAction.getDatetime())) .build(); }
@Override protected String getBottomUserDate() { return mRequest.getCreatedAt(); }
@Override protected String getBottomUserComment() { return getRequestItem().getCreatedComment(); }
/** * @return true if this request has already been closed */ public boolean isClosed() { return getClosedBy() != null && !getClosedBy().isEmpty(); }
@Override protected List<String> getTopPictures() { return getRequestItem().getClosedPictures(); }
@Override protected String getTopUserComment() { return getRequestItem().getClosedComment(); }