package eu.smartlm.abs.portal.graph;
import java.util.Set;
import org.gridforum.x2003.urWg.HostDocument.Host;
import org.gridforum.x2003.urWg.ProjectNameDocument.ProjectName;
import org.gridforum.x2003.urWg.SubmitHostDocument.SubmitHost;
import org.gridforum.x2003.urWg.UserIdentityDocument.UserIdentity;
import org.jfree.data.category.DefaultCategoryDataset;
import eu.smartlm.abs.portal.data.aggregation.DataAggregation;
import eu.smartlm.abs.portal.view.portlet.QueryPortlet;
import eu.smartlm.schemas.x2009.x06.urec.ProductType;
import eu.smartlm.schemas.x2009.x06.urec.SmartLMUsageRecordType;
/**
* This class is the responsible to build the different graphs taht are going to be shown in the Accounting and Billing Portal
* @author David García Pérez - CESGA
*
*/
public class DatasetConstructor {
/**
* This method creates the necessary Dataset to create a graph based on User usage information for some specific set of products
* @param usageRecords UsageRecords from where to extract the used hours
* @param users list of users that are going to appear in the dataset
* @param products list of selected applications to be calculate the hours
* @param type accounting or billing
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForUsageVsUsersFilterByProducts(
Set<SmartLMUsageRecordType> usageRecords,
Set<UserIdentity> users,
Set<ProductType> products,
String type) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users)
for(ProductType product : products)
dataset.addValue(DataAggregation.determineUsageByProduct(usageRecords, user, product, type), product.getName(), user.getLocalUserId());
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on Product usage information for some specific set of users
* @param usageRecords UsageRecords from where to extract the used hours
* @param users list of users that are going to appear in the dataset
* @param products list of selected applications to be calculate the hours
* @param type accounting or billing
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForUsageVsProductsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords,
Set<UserIdentity> users,
Set<ProductType> products,
String type) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users)
for(ProductType product : products)
dataset.addValue(DataAggregation.determineUsageByProduct(usageRecords, user, product, type), user.getLocalUserId(), product.getName());
return dataset;
}
/**
* It creates a Dataset to create a graph of Product usage vs time
* @param usageRecords usage records from where the usage information is going to be extracted
* @param products list of product from where we are interested to know the usage information
* @param type accounting and billing
* @return the necessary dataset to make the graph
*/
public static DefaultCategoryDataset constructDatasetForUsageVsProduct(Set<SmartLMUsageRecordType> usageRecords, Set<ProductType> products, String type) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(ProductType product : products)
dataset.addValue(DataAggregation.determineUsageForAProduct(usageRecords, product, type), "category", product.getName());
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on User usage information for some specific set of accountingGroups
* @param usageRecords UsageRecords from where to extract the used hours
* @param users list of users that are going to appear in the dataset
* @param accountingGroups list of selected applications to be calculate the hours
* @param type accounting or billing
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForUsageVsUsersFilterByAccountingGroups(
Set<SmartLMUsageRecordType> usageRecords,
Set<UserIdentity> users,
Set<String> accountingGroups,
String type) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users)
for(String accountingGroup : accountingGroups)
dataset.addValue(DataAggregation.determineUsageByAccountingGroup(usageRecords, user, accountingGroup, type), accountingGroup, user.getLocalUserId());
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on AccountingGroup usage information for some specific set of Users
* @param usageRecords UsageRecords from where to extract the used hours
* @param users list of users that are going to appear in the dataset
* @param accountingGroups list of selected applications to be calculate the hours
* @param type accounting or billing
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForUsageVsAccountingGroupsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords,
Set<UserIdentity> users,
Set<String> accountingGroups,
String type) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users)
for(String accountingGroup : accountingGroups)
dataset.addValue(
DataAggregation.determineUsageByAccountingGroup(usageRecords, user, accountingGroup, type),
user.getLocalUserId(),
accountingGroup);
return dataset;
}
/**
* This method creates a dataset of time usage for AccountingGroups filtered by Users
* @param usageRecords usageRecords where to extract information
* @param departments from where we are going to calculate the time usage
* @param users from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsAccountingGroupFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups,
Set<UserIdentity> users) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users) {
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroup(usageRecords, accountingGroup, QueryPortlet.TYPE_ACCOUNTING),
user.getLocalUserId(),
accountingGroup);
}
}
return dataset;
}
/**
* This method creates a dataset of billing usage for AccountingGroups filtered by Users
* @param usageRecords usageRecords where to extract information
* @param departments from where we are going to calculate the time usage
* @param users from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsAccountingGroupFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups,
Set<UserIdentity> users) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users) {
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroup(usageRecords, accountingGroup, QueryPortlet.TYPE_BILLING),
user.getLocalUserId(),
accountingGroup);
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on User usage information for some specific set of machines (Host)
* @param usageRecords UsageRecords from where to extract to the used hours
* @param users list of users that are going to appear in the dataset
* @param hosts list of selected hosts machines to be calculate the hours
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsUsersFilterByHosts(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<Host> hosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(Host host : hosts) {
dataset.addValue(
DataAggregation.determineUsageByHost(usageRecords, user, host, QueryPortlet.TYPE_ACCOUNTING),
host.getStringValue(),
user.getLocalUserId());
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on User billing usage information for some specific set of machines (Host)
* @param usageRecords UsageRecords from where to extract to the used hours
* @param users list of users that are going to appear in the dataset
* @param hosts list of selected hosts machines to be calculate the hours
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsUsersFilterByHosts(Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users, Set<Host> hosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(Host host : hosts) {
dataset.addValue(
DataAggregation.determineUsageByHost(usageRecords, user, host, QueryPortlet.TYPE_BILLING),
host.getStringValue(),
user.getLocalUserId());
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on Hosts usage information for some specific set of Users
* @param usageRecords UsageRecords from where to extract to the used hours
* @param hosts list of selected hosts machines to be calculate the hours
* @param users list of users that are going to appear in the dataset
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsHostsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<Host> hosts, Set<UserIdentity> users) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(Host host : hosts) {
dataset.addValue(
DataAggregation.determineUsageByHost(usageRecords, user, host, QueryPortlet.TYPE_ACCOUNTING),
user.getLocalUserId(),
host.getStringValue());
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on Hosts billing usage information for some specific set of Users
* @param usageRecords UsageRecords from where to extract to the used hours
* @param hosts list of selected hosts machines to be calculate the hours
* @param users list of users that are going to appear in the dataset
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsHostsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<Host> hosts, Set<UserIdentity> users) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(Host host : hosts) {
dataset.addValue(
DataAggregation.determineUsageByHost(usageRecords, user, host, QueryPortlet.TYPE_BILLING),
user.getLocalUserId(),
host.getStringValue());
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on User usage information for some specific set of machines (submitHost)
* @param usageRecords UsageRecords from where to extract to the used hours
* @param users list of users that are going to appear in the dataset
* @param submitHosts list of selected submithosts machines to be calculate the hours
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsUsersFilterBySubmitHosts(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<SubmitHost> submitHosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageBySubmitHost(usageRecords, user, submitHost, QueryPortlet.TYPE_ACCOUNTING),
submitHost.getStringValue(),
user.getLocalUserId());
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on User billing usage information for some specific set of machines (submitHost)
* @param usageRecords UsageRecords from where to extract to the used hours
* @param users list of users that are going to appear in the dataset
* @param submitHosts list of selected submithosts machines to be calculate the hours
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsUsersFilterBySubmitHosts(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<SubmitHost> submitHosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageBySubmitHost(usageRecords, user, submitHost, QueryPortlet.TYPE_BILLING),
submitHost.getStringValue(),
user.getLocalUserId());
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on machines (submitHost) usage information for some specific set of User
* @param usageRecords UsageRecords from where to extract to the used hours
* @param submitHosts list of selected submithosts machines to be calculate the hours
* @param users list of users that are going to appear in the dataset
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsSubmitHostsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<SubmitHost> submitHosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageBySubmitHost(usageRecords, user, submitHost, QueryPortlet.TYPE_ACCOUNTING),
user.getLocalUserId(),
submitHost.getStringValue());
}
}
return dataset;
}
/**
* This method creates the necessary Dataset to create a graph based on machines (submitHost) billing usage information for some specific set of User
* @param usageRecords UsageRecords from where to extract to the used hours
* @param submitHosts list of selected submithosts machines to be calculate the hours
* @param users list of users that are going to appear in the dataset
* @return the dataset ready to make a graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsSubmitHostsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<SubmitHost> submitHosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageBySubmitHost(usageRecords, user, submitHost, QueryPortlet.TYPE_BILLING),
user.getLocalUserId(),
submitHost.getStringValue());
}
}
return dataset;
}
/**
* This method creates a dataset of time usage for users
* @param usageRecords usageRecords where to extract information
* @param users from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
dataset.addValue(
DataAggregation.determineUsageForAUser(usageRecords, user, QueryPortlet.TYPE_ACCOUNTING), "category", user.getLocalUserId());
}
return dataset;
}
/**
* This method creates a dataset of billing usage for users
* @param usageRecords usageRecords where to extract information
* @param users from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsUsers(Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user: users) {
dataset.addValue(
DataAggregation.determineUsageForAUser(usageRecords, user, QueryPortlet.TYPE_ACCOUNTING), "category", user.getLocalUserId());
}
return dataset;
}
/**
* This method creates a dataset of billing usage for Departments
* @param usageRecords usageRecords where to extract information
* @param accountingGroups from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsAccountingGroup(Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroup(usageRecords, accountingGroup, QueryPortlet.TYPE_ACCOUNTING),
"category",
accountingGroup);
}
return dataset;
}
/**
* This method creates a Billing dataset of billing usage for Departments
* @param usageRecords usageRecords where to extract information
* @param accountingGroups from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsAccountingGroup(Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroup(usageRecords, accountingGroup, QueryPortlet.TYPE_BILLING),
"category",
accountingGroup);
}
return dataset;
}
/**
* This method creates a dataset of usage for Projects
* @param usageRecords usageRecords where to extract information
* @param projectss from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProject(
Set<SmartLMUsageRecordType>usageRecords, Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(ProjectName project : projects) {
dataset.addValue(DataAggregation.determineUsageForAProject(usageRecords, project, QueryPortlet.TYPE_ACCOUNTING), "category", project.getStringValue());
}
return dataset;
}
/**
* This method creates a dataset of billing usage for Projects
* @param usageRecords usageRecords where to extract information
* @param projectss from where we are going to calculate the time usage
* @return the dataset to construct the graph.
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProject(
Set<SmartLMUsageRecordType>usageRecords, Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(ProjectName project : projects) {
dataset.addValue(DataAggregation.determineUsageForAProject(usageRecords, project, QueryPortlet.TYPE_BILLING), "category", project.getStringValue());
}
return dataset;
}
/**
* This method creates a dataset of user usage filtered by projects
* @param usageRecords sets of usage records
* @param users list of users
* @param projects list of projects
* @return dataset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsUsersFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProject(usageRecords, user, project, QueryPortlet.TYPE_ACCOUNTING),
user.getLocalUserId(),
project.getStringValue());
}
}
return dataset;
}
/**
* This method creates a dataset of user billing usage filtered by projects
* @param usageRecords sets of usage records
* @param users list of users
* @param projects list of projects
* @return dataset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsUsersFilterByProjects(Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users, Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProject(usageRecords, user, project, QueryPortlet.TYPE_BILLING),
user.getLocalUserId(),
project.getStringValue());
}
}
return dataset;
}
/**
* This method creates a dataset of project usage filtered by users
* @param usageRecords sets of usage records
* @param users list of users
* @param projects list of projects
* @return dataset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProjectsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProject(usageRecords, user, project, QueryPortlet.TYPE_ACCOUNTING),
project.getStringValue(),
user.getLocalUserId());
}
}
return dataset;
}
/**
* This method creates a dataset of project billing usage filtered by users
* @param usageRecords sets of usage records
* @param users list of users
* @param projects list of projects
* @return dataset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProjectsFilterByUsers(
Set<SmartLMUsageRecordType> usageRecords, Set<UserIdentity> users,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(UserIdentity user : users) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProject(usageRecords, user, project, QueryPortlet.TYPE_BILLING),
project.getStringValue(),
user.getLocalUserId());
}
}
return dataset;
}
/**
* This method creates a dataset of Products usage filtered by Departments
* @param usageRecords UsageRecords from where to extract the information
* @param departments Departments from which we are interested
* @param products Productos from which we are interested
* @return the dataset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProductsFilterByAccountingGroups(
Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageForProductByAccountingGroup(usageRecords, product, accountingGroup, QueryPortlet.TYPE_ACCOUNTING),
accountingGroup,
product.getName());
}
}
return dataset;
}
/**
* This method creates a dataset of Products billing usage filtered by Departments
* @param usageRecords UsageRecords from where to extract the information
* @param departments Departments from which we are interested
* @param products Productos from which we are interested
* @return the dataset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProductsFilterByAccountingGroups(
Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageForProductByAccountingGroup(usageRecords, product, accountingGroup, QueryPortlet.TYPE_BILLING),
accountingGroup,
product.getName());
}
}
return dataset;
}
/**
* This method creates a dataset of Products usage filtered by AccountingGroups
* @param usageRecords UsageRecords from where to extract the information
* @param departments Departments from which we are interested
* @param products Products from which we are interested
* @return the dataset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsAccountingGroupFilterByProducts(
Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageForProductByAccountingGroup(usageRecords, product, accountingGroup, QueryPortlet.TYPE_ACCOUNTING),
product.getName(),
accountingGroup);
}
}
return dataset;
}
/**
* This method creates a dataset of Products billing usage filtered by AccountingGroups
* @param usageRecords UsageRecords from where to extract the information
* @param departments Departments from which we are interested
* @param products Products from which we are interested
* @return the dataset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsAccountingGroupFilterByProducts(
Set<SmartLMUsageRecordType> usageRecords, Set<String> accountingGroups,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageForProductByAccountingGroup(usageRecords, product, accountingGroup, QueryPortlet.TYPE_BILLING),
product.getName(),
accountingGroup);
}
}
return dataset;
}
/**
* This method creates a dataset of AccountingGroups Filtered by Projects
* @param usageRecords Usage records from where to extract the information
* @param accountingGroups
* @param projects
* @return the dataset to create a graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsAccountingGroupFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<String> accountingGroups,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroupFilterByProject(usageRecords,accountingGroup, project, QueryPortlet.TYPE_ACCOUNTING),
project.getStringValue(),
accountingGroup);
}
}
return dataset;
}
/**
* This method creates a billing dataset of AccountingGroups Filtered by Projects
* @param usageRecords Usage records from where to extract the information
* @param accountingGroups
* @param projects
* @return the dataset to create a graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsAccountingGroupFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<String> accountingGroups,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroupFilterByProject(usageRecords,accountingGroup, project, QueryPortlet.TYPE_BILLING),
project.getStringValue(),
accountingGroup);
}
}
return dataset;
}
/**
* This method creates a dataset of Projectss Filtered by AccountingGroups
* @param usageRecords Usage records from where to extract the information
* @param accountingGroups
* @param projects
* @return the dataset to create a graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProjectsFilterByAccountingGroups(
Set<SmartLMUsageRecordType> usageRecords,
Set<String> accountingGroups,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroupFilterByProject(usageRecords,accountingGroup, project, QueryPortlet.TYPE_ACCOUNTING),
accountingGroup,
project.getStringValue());
}
}
return dataset;
}
/**
* This method creates a billing dataset of Projects Filtered by AccountingGroups
* @param usageRecords Usage records from where to extract the information
* @param accountingGroups
* @param projects
* @return the dataset to create a graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProjectsFilterByAccountingGroups(
Set<SmartLMUsageRecordType> usageRecords,
Set<String> accountingGroups,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageForAnAccountingGroupFilterByProject(usageRecords,accountingGroup, project, QueryPortlet.TYPE_BILLING),
accountingGroup,
project.getStringValue());
}
}
return dataset;
}
/**
* It creates a dataset of SubmitHosts filter by AccountingGroups
* @param smartLMUsageRecords
* @param submitHosts
* @param accountingGroups
* @return
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsSubmitHostFilterByAccountingGroup(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterBySubmitHost(usageRecords, accountingGroup, submitHost, QueryPortlet.TYPE_ACCOUNTING),
accountingGroup,
submitHost.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing dataset of SubmitHosts filter by AccountingGroups
* @param smartLMUsageRecords
* @param submitHosts
* @param accountingGroups
* @return
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsSubmitHostFilterByAccountingGroup(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterBySubmitHost(usageRecords, accountingGroup, submitHost, QueryPortlet.TYPE_BILLING),
accountingGroup,
submitHost.getStringValue());
}
}
return dataset;
}
/**
* It creates a dataset of AccountingGroups filter by SubmitHosts
* @param smartLMUsageRecords
* @param submitHosts
* @param accountingGroups
* @return the usage dataset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsAccountingGroupFilterBySubmitHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterBySubmitHost(usageRecords, accountingGroup, submitHost, QueryPortlet.TYPE_ACCOUNTING),
submitHost.getStringValue(),
accountingGroup);
}
}
return dataset;
}
/**
* It creates a billing dataset of AccountingGroups filter by SubmitHosts
* @param smartLMUsageRecords
* @param submitHosts
* @param accountingGroups
* @return the billing dataset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsAccountingGroupFilterBySubmitHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(String accountingGroup : accountingGroups) {
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterBySubmitHost(usageRecords, accountingGroup, submitHost, QueryPortlet.TYPE_BILLING),
submitHost.getStringValue(),
accountingGroup);
}
}
return dataset;
}
/**
* It creates a dataset of Products filtered by Projects
* @param usageRecords UsageRecords from where to extract the information
* @param projects Projects from which we are interested
* @param products Products from which we are interested
* @return the dateset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProductsFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<ProjectName> projects,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(ProjectName project : projects) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByProject(usageRecords, product, project, QueryPortlet.TYPE_ACCOUNTING),
project.getStringValue(),
product.getName());
}
}
return dataset;
}
/**
* It creates a billing dataset of Products filtered by Projects
* @param usageRecords UsageRecords from where to extract the information
* @param projects Projects from which we are interested
* @param products Products from which we are interested
* @return the dateset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProductsFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<ProjectName> projects,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(ProjectName project : projects) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByProject(usageRecords, product, project, QueryPortlet.TYPE_BILLING),
project.getStringValue(),
product.getName());
}
}
return dataset;
}
/**
* It creates a dataset of Products filtered by Projects
* @param usageRecords UsageRecords from where to extract the information
* @param projects Projects from which we are interested
* @param products Products from which we are interested
* @return the dateset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProjectsFilterByProducts(
Set<SmartLMUsageRecordType>
usageRecords,
Set<ProjectName> projects,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(ProjectName project : projects) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByProject(usageRecords, product, project, QueryPortlet.TYPE_ACCOUNTING),
product.getName(),
project.getStringValue());
}
}
return dataset;
}
/**
* It creates a billing dataset of Products filtered by Projects
* @param usageRecords UsageRecords from where to extract the information
* @param projects Projects from which we are interested
* @param products Products from which we are interested
* @return the billing dateset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProjectsFilterByProducts(
Set<SmartLMUsageRecordType>
usageRecords,
Set<ProjectName> projects,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(ProjectName project : projects) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByProject(usageRecords, product, project, QueryPortlet.TYPE_BILLING),
product.getName(),
project.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of SubmitHosts filtered by Products
* @param usageRecords Usage records from where to extract the information
* @param submitHosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsSubmitHostsFilterByProducts(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterBySubmitHost(usageRecords, product, submitHost, QueryPortlet.TYPE_ACCOUNTING),
product.getName(),
submitHost.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of SubmitHosts filtered by Products
* @param usageRecords Usage records from where to extract the information
* @param submitHosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsSubmitHostsFilterByProducts(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterBySubmitHost(usageRecords, product, submitHost, QueryPortlet.TYPE_BILLING),
product.getName(),
submitHost.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of Host usage filter by accountingGroups
* @param usageRecords
* @param hosts
* @param accountingGroups
* @return the dataset
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsHostFilterByAccountingGroup(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterByHost(usageRecords, accountingGroup, host, QueryPortlet.TYPE_ACCOUNTING),
accountingGroup,
host.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of Host usage filter by accountingGroups
* @param usageRecords
* @param hosts
* @param accountingGroups
* @return the dataset
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsHostFilterByAccountingGroup(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterByHost(usageRecords, accountingGroup, host, QueryPortlet.TYPE_BILLING),
accountingGroup,
host.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of AccountingGroups filter by Hosts
* @param smartLMUsageRecords
* @param hosts
* @param accountingGroups
* @return
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsAccountingGroupFilterByHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterByHost(usageRecords, accountingGroup, host, QueryPortlet.TYPE_ACCOUNTING),
host.getStringValue(),
accountingGroup);
}
}
return dataset;
}
/**
* It creates a Billing Dataset of AccountingGroups filter by Hosts
* @param smartLMUsageRecords
* @param hosts
* @param accountingGroups
* @return
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsAccountingGroupFilterByHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<String> accountingGroups) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(String accountingGroup : accountingGroups) {
dataset.addValue(
DataAggregation.determineUsageByAccountingGroupFilterByHost(usageRecords, accountingGroup, host, QueryPortlet.TYPE_BILLING),
host.getStringValue(),
accountingGroup);
}
}
return dataset;
}
/**
* It creates a Dataset of Products filtered by SubmitHosts
* @param usageRecords Usage records from where to extract the information
* @param submitHosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProductsFilterBySubmitHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterBySubmitHost(usageRecords, product, submitHost, QueryPortlet.TYPE_ACCOUNTING),
submitHost.getStringValue(),
product.getName());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of Products filtered by SubmitHosts
* @param usageRecords Usage records from where to extract the information
* @param submitHosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProductsFilterBySubmitHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterBySubmitHost(usageRecords, product, submitHost, QueryPortlet.TYPE_BILLING),
submitHost.getStringValue(),
product.getName());
}
}
return dataset;
}
/**
* It creates a Dataset of Hosts filtered by Products
* @param usageRecords Usage records from where to extract the information
* @param hosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the datase to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsHostsFilterByProducts(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByHost(usageRecords, product, host, QueryPortlet.TYPE_ACCOUNTING),
product.getName(),
host.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of Hosts filtered by Products
* @param usageRecords Usage records from where to extract the information
* @param hosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the datase to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsHostsFilterByProducts(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByHost(usageRecords, product, host, QueryPortlet.TYPE_BILLING),
product.getName(),
host.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of Products filtered by Hosts
* @param usageRecords Usage records from where to extract the information
* @param hosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the datase to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProductsFilterByHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByHost(usageRecords, product, host, QueryPortlet.TYPE_ACCOUNTING),
host.getStringValue(),
product.getName());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of Products filtered by Hosts
* @param usageRecords Usage records from where to extract the information
* @param hosts Hosts from which we are interested
* @param products Products from which we are interested
* @return the datase to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProductsFilterByHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProductType> products) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProductType product : products) {
dataset.addValue(
DataAggregation.determineUsageByProductFilterByHost(usageRecords, product, host, QueryPortlet.TYPE_BILLING),
host.getStringValue(),
product.getName());
}
}
return dataset;
}
/**
* It creates a Dataset of Projects filtered by Hosts
* @param usageRecords
* @param hosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProjectFilterByHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterByHost(usageRecords, project, host, QueryPortlet.TYPE_ACCOUNTING),
host.getStringValue(),
project.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of Projects filtered by Hosts
* @param usageRecords
* @param hosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProjectFilterByHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterByHost(usageRecords, project, host, QueryPortlet.TYPE_BILLING),
host.getStringValue(),
project.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of Hosts filtered by Projects
* @param usageRecords
* @param hosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsHostFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterByHost(usageRecords, project, host, QueryPortlet.TYPE_ACCOUNTING),
project.getStringValue(),
host.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of Hosts filtered by Projects
* @param usageRecords
* @param hosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsHostFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterByHost(usageRecords, project, host, QueryPortlet.TYPE_BILLING),
project.getStringValue(),
host.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of Projects Filtered by SumbitHosts
* @param usageRecords
* @param submitHosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsProjectFilterBySubmitHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterBySubmitHost(usageRecords, project, submitHost, QueryPortlet.TYPE_ACCOUNTING),
submitHost.getStringValue(),
project.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of Projects Filtered by SumbitHosts
* @param usageRecords
* @param submitHosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsProjectFilterBySubmitHosts(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterBySubmitHost(usageRecords, project, submitHost, QueryPortlet.TYPE_BILLING),
submitHost.getStringValue(),
project.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of SubmitHost Filtered by Projects
* @param usageRecords
* @param submitHosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageVsSumitHostFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterBySubmitHost(usageRecords, project, submitHost, QueryPortlet.TYPE_ACCOUNTING),
project.getStringValue(),
submitHost.getStringValue());
}
}
return dataset;
}
/**
* It creates a Billing Dataset of SubmitHost Filtered by Projects
* @param usageRecords
* @param submitHosts
* @param projects
* @return the dataset to create the graph
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageVsSumitHostFilterByProjects(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts,
Set<ProjectName> projects) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
for(ProjectName project : projects) {
dataset.addValue(
DataAggregation.determineUsageByProjectFilterBySubmitHost(usageRecords, project, submitHost, QueryPortlet.TYPE_BILLING),
project.getStringValue(),
submitHost.getStringValue());
}
}
return dataset;
}
/**
* It creates a Dataset of Hosts time usage
* @param smartLMUsageRecords
* @param hosts
* @return
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageForAHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
dataset.addValue(DataAggregation.determineUsageForAHost(usageRecords, host, QueryPortlet.TYPE_ACCOUNTING), "category", host.getStringValue());
}
return dataset;
}
/**
* It creates a Dataset of Hosts time usage
* @param smartLMUsageRecords
* @param hosts
* @return
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageForAHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<Host> hosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(Host host : hosts) {
dataset.addValue(DataAggregation.determineUsageForAHost(usageRecords, host, QueryPortlet.TYPE_ACCOUNTING), "category", host.getStringValue());
}
return dataset;
}
/**
* It creates a Dataset of SubmitHosts time usage
* @param usageRecords
* @param submitHosts
* @return
*/
public static DefaultCategoryDataset constructDatasetForTimeUsageForASubmitHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(DataAggregation.determineUsageForASubmitHost(usageRecords, submitHost, QueryPortlet.TYPE_ACCOUNTING), "category", submitHost.getStringValue());
}
return dataset;
}
/**
* It creates a Billing Dataset of SubmitHosts time usage
* @param usageRecords
* @param submitHosts
* @return
*/
public static DefaultCategoryDataset constructDatasetForBillingUsageForASubmitHost(
Set<SmartLMUsageRecordType> usageRecords,
Set<SubmitHost> submitHosts) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for(SubmitHost submitHost : submitHosts) {
dataset.addValue(DataAggregation.determineUsageForASubmitHost(usageRecords, submitHost, QueryPortlet.TYPE_BILLING), "category", submitHost.getStringValue());
}
return dataset;
}
}