Get the list of exports for a specific iteration.

@param projectId The project id
@param iterationId The iteration id
@throws IllegalArgumentException thrown if parameters fail the validation
@return the observable to the List&lt;Export&gt; object
973434
public Observable<ServiceResponse<List<Export>>> getExportsWithServiceResponseAsync(UUID projectId, UUID iterationId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (iterationId == null) {
            throw new IllegalArgumentException("Parameter iterationId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.getExports(projectId, iterationId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<Export>>>>() {
                @Override
                public Observable<ServiceResponse<List<Export>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<Export>> clientResponse = getExportsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
638939
public Observable<ServiceResponse<Iteration>> trainProjectWithServiceResponseAsync(UUID projectId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.trainProject(projectId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Iteration>>>() {
                @Override
                public Observable<ServiceResponse<Iteration>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Iteration> clientResponse = trainProjectDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
844868
public List<GitlabBadge> getProjectBadges(Serializable projectId) throws IOException {
        String tailUrl = GitlabProject.URL + "/" + sanitizeProjectId(projectId) + GitlabBadge.URL;
        return Arrays.asList(retrieve().to(tailUrl, GitlabBadge[].class));
    }
192948
public Map<Integer, String> listProjects() throws MPXJException
   {
      try
      {
         Map<Integer, String> result = new HashMap<Integer, String>();

         List<Row> rows = getRows("select proj_id, proj_short_name from " + m_schema + "project where delete_date is null");
         for (Row row : rows)
         {
            Integer id = row.getInteger("proj_id");
            String name = row.getString("proj_short_name");
            result.put(id, name);
         }

         return result;
      }

      catch (SQLException ex)
      {
         throw new MPXJException(MPXJException.READ_ERROR, ex);
      }
   }
242214
protected void processProjectListItem(Map<Integer, String> result, Row row)
   {
      Integer id = row.getInteger("PROJ_ID");
      String name = row.getString("PROJ_NAME");
      result.put(id, name);
   }
572345
@RequestMapping(value = "changelog/export/{projectId}/formats", method = RequestMethod.GET)
    public Resources<ExportFormat> changeLogExportFormats(@PathVariable ID projectId) {
        // Gets the project
        Project project = structureService.getProject(projectId);
        // Gets the configuration for the project
        GitConfiguration projectConfiguration = gitService.getProjectConfiguration(project);
        if (projectConfiguration != null) {
            Optional<ConfiguredIssueService> configuredIssueService = projectConfiguration.getConfiguredIssueService();
            if (configuredIssueService.isPresent()) {
                return Resources.of(
                        configuredIssueService.get().getIssueServiceExtension().exportFormats(
                                configuredIssueService.get().getIssueServiceConfiguration()
                        ),
                        uri(on(GitController.class).changeLogExportFormats(projectId))
                );
            }
        }
        // Not found
        return Resources.of(
                Collections.emptyList(),
                uri(on(GitController.class).changeLogExportFormats(projectId))
        );
    }
25326
public Observable<Project> getProjectAsync(UUID projectId) {
        return getProjectWithServiceResponseAsync(projectId).map(new Func1<ServiceResponse<Project>, Project>() {
            @Override
            public Project call(ServiceResponse<Project> response) {
                return response.body();
            }
        });
    }
1092493
public static Trajectory getTrajectoryByID(List<? extends Trajectory> t, int id){
		Trajectory track = null;
		for(int i = 0; i < t.size() ; i++){
			if(t.get(i).getID()==id){
				track = t.get(i);
				break;
			}
		}
		return track;
	}
899402
public Observable<SubscriptionInner> getAsync(String subscriptionId) {
        return getWithServiceResponseAsync(subscriptionId).map(new Func1<ServiceResponse<SubscriptionInner>, SubscriptionInner>() {
            @Override
            public SubscriptionInner call(ServiceResponse<SubscriptionInner> response) {
                return response.body();
            }
        });
    }
60232
public Observable<ServiceResponse<Void>> deleteImageRegionsWithServiceResponseAsync(UUID projectId, List<String> regionIds) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (regionIds == null) {
            throw new IllegalArgumentException("Parameter regionIds is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        Validator.validate(regionIds);
        String regionIdsConverted = this.client.serializerAdapter().serializeList(regionIds, CollectionFormat.CSV);
        return service.deleteImageRegions(projectId, regionIdsConverted, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteImageRegionsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
371470
private Map<String, Integer> getAttemptsMap(String projectId, String eventCollection) throws IOException {
        Map<String, Integer> attempts = new HashMap<String, Integer>();
        if (eventStore instanceof KeenAttemptCountingEventStore) {
            KeenAttemptCountingEventStore res = (KeenAttemptCountingEventStore)eventStore;
            String attemptsJSON = res.getAttempts(projectId, eventCollection);
            if (attemptsJSON != null) {
                StringReader reader = new StringReader(attemptsJSON);
                Map<String, Object> attemptTmp = jsonHandler.readJson(reader);
                for (Entry<String, Object> entry : attemptTmp.entrySet()) {
                    if (entry.getValue() instanceof Number) {
                        attempts.put(entry.getKey(), ((Number)entry.getValue()).intValue());
                    }
                }
            }
        }

        return attempts;
    }
158860
public Observable<OperationListResultInner> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<OperationListResultInner>, OperationListResultInner>() {
            @Override
            public OperationListResultInner call(ServiceResponse<OperationListResultInner> response) {
                return response.body();
            }
        });
    }
486267
@GetMapping("/mappingproject/{id}")
  public String viewMappingProject(@PathVariable("id") String identifier, Model model) {
    MappingProject project = mappingService.getMappingProject(identifier);
    MappingTarget mappingTarget = project.getMappingTargets().get(0);
    String target = mappingTarget.getName();
    model.addAttribute("entityTypes", getNewSources(mappingTarget));
    model.addAttribute(
        "compatibleTargetEntities",
        mappingService.getCompatibleEntityTypes(mappingTarget.getTarget()).collect(toList()));
    model.addAttribute("selectedTarget", target);
    model.addAttribute("mappingProject", project);
    model.addAttribute("attributeTagMap", getTagsForAttribute(target, project));
    model.addAttribute(
        "packages",
        dataService
            .getMeta()
            .getPackages()
            .stream()
            .filter(p -> !isSystemPackage(p))
            .collect(toList()));
    return VIEW_SINGLE_MAPPING_PROJECT;
  }
1238884
def get_project_export(self, project_id):
        
        try:
            result = self._request('/getprojectexport/',
                                   {'projectid': project_id})
            return TildaProject(**result)
        except NetworkError:
            return []
1232573
public Observable<List<Iteration>> getIterationsAsync(UUID projectId) {
        return getIterationsWithServiceResponseAsync(projectId).map(new Func1<ServiceResponse<List<Iteration>>, List<Iteration>>() {
            @Override
            public List<Iteration> call(ServiceResponse<List<Iteration>> response) {
                return response.body();
            }
        });
    }
905290
def get_project_collection(self, collection_id):
        
        route_values = {}
        if collection_id is not None:
            route_values['collectionId'] = self._serialize.url('collection_id', collection_id, 'str')
        response = self._send(http_method='GET',
                              location_id='8031090f-ef1d-4af6-85fc-698cd75d42bf',
                              version='5.1-preview.2',
                              route_values=route_values)
        return self._deserialize('TeamProjectCollection', response)
737975
def get_iterations(project_id, custom_headers:nil)
      response = get_iterations_async(project_id, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end