/**
* The transaction registers the negated sum of the shares as an expense by a group of
* contributors. Additionally all the shares in the map are registered with the same entry id.
* Those names in the deals map that are empty <code>String</code> trigger transfers of internal
* amounts. Such an internal transfer is not allowed if the transaction causes a negative total.
*
* @param deals the names of the contributors and their contributions who expended an amount
* matching the negated sum of the deals
* @param comment a <code>String</code> to make the transaction recognizable
* @param shares a <code>ShareMap</code> containing the shares of participants involved
* @return the entry id of the transaction or a negative value in case the transaction failed
*/
public int performComplexExpense(ShareMap deals, String comment, ShareMap shares) {
int entryId = -1;
int transactionCode = 3;
int flags = composeFlags(transactionCode, true);
double amount = deals.sum();
if (Math.abs(amount + shares.sum()) < ShareUtil.delta) {
if (deals.option != null)
switch (deals.option) {
default:
setDebtLimit(1000. * deals.option);
break;
}
if (deals.rawMap.containsKey(kitty))
entryId = performTransfer(kitty, -deals.rawMap.get(kitty), comment, kitty);
else entryId = getNewEntryId();
Collection<String> dealers = ShareUtil.filter(deals.rawMap.keySet(), true, ShareUtil.isKitty);
for (String name : dealers) {
long rowId =
addRecord(
entryId,
name,
deals.rawMap.get(name),
currency,
Helper.timestampNow(),
comment,
flags);
if (rowId < 0) {
entryId = -1;
break;
}
}
} else
Log.w(
TAG,
String.format(
"the sum of the deals (%f) for '%s' doesn't match the sum of the shares (%f)",
amount, comment, shares.sum()));
if (entryId > -1) {
if (allocate(flags, entryId, shares.rawMap)) {
Log.i(
TAG,
String.format(
"entry %d: %s expended %f %s for '%s' shared by %s",
entryId, deals.toString(), Math.abs(amount), currency, comment, shares.toString()));
} else {
removeEntry(entryId);
entryId = -1;
}
}
if (entryId < 0) removeEntry(entryId);
return entryId;
}
/**
* The transaction registers the negated sum of the shares with the submitter. Additionally all
* the shares in the map are registered with the same entry id. This transaction does not change
* the total. It registers an allocation of a certain amount. If submitter is an empty <code>
* String</code> it means there is an internal reallocation which is not an expense. Such an
* internal reallocation is not allowed if the transaction causes a negative total.
*
* @param submitter the name of the participant who expended an amount matching the negated sum of
* the shares
* @param comment a <code>String</code> to make the transaction recognizable
* @param shares a <code>ShareMap</code> containing the shares of participants involved
* @return the entry id of the transaction or -1 in case the transaction failed or -2 if the
* transaction violates the 'no negative total' rule
*/
public int performExpense(String submitter, String comment, ShareMap shares) {
double amount = -shares.sum();
boolean internal = isInternal(submitter);
if (internal) {
if (breaksDebtLimit(-amount)) return -2;
}
int transactionCode = 3;
int flags = composeFlags(transactionCode, !internal);
int entryId = addEntry(submitter, amount, currency, comment, flags);
if (entryId < 0) return -1;
if (allocate(flags, entryId, shares.rawMap)) {
String action = internal ? "reallocation of" : submitter + " expended";
Log.i(
TAG,
String.format(
"entry %d: %s %f %s for '%s' shared by %s",
entryId, action, Math.abs(amount), currency, comment, shares.toString()));
} else {
removeEntry(entryId);
entryId = -1;
}
return entryId;
}
public static String getNextFeatureTemp() {
int featureTitledCount = 0;
for (String name : new File(tempPath()).list())
if (name.startsWith(FEATURE))
try {
featureTitledCount =
Math.max(featureTitledCount, Integer.parseInt(name.substring(FEATURE.length())));
} catch (NumberFormatException nf) {
}
return FEATURE + "_" + (featureTitledCount + 1);
}
/**
* The transaction registers the amount as a contribution (positive) or a retrieval (negative). A
* retrieval is not allowed if it surmounts the current total.
*
* @param submitter the name of the participant who did the submission
* @param amount the amount of the submission
* @param comment a <code>String</code> to make the transaction recognizable
* @return the entry id of the transaction or -1 in case the transaction failed or -2 if the
* transaction violates the 'no negative total' rule
*/
public int performSubmission(String submitter, double amount, String comment) {
int transactionCode = 1;
int flags = composeFlags(transactionCode, false);
int entryId = addEntry(submitter, amount, currency, comment, flags);
if (entryId > -1) {
if (breaksDebtLimit(-amount)) {
removeEntry(entryId);
return -2;
}
String action = amount > 0 ? "contributed" : "retrieved";
Log.i(
TAG,
String.format(
"entry %d: %s %s %f %s as '%s'",
entryId, submitter, action, Math.abs(amount), currency, comment));
}
return entryId;
}