static private FinancialDependencyType GetFinancialDependencyType(IHasIdentity foreignObject)
{
if (foreignObject is ExpenseClaim)
{
return(FinancialDependencyType.ExpenseClaim);
}
else if (foreignObject is InboundInvoice)
{
return(FinancialDependencyType.InboundInvoice);
}
else if (foreignObject is OutboundInvoice)
{
return(FinancialDependencyType.OutboundInvoice);
}
else if (foreignObject is Salary)
{
return(FinancialDependencyType.Salary);
}
else if (foreignObject is Payout)
{
return(FinancialDependencyType.Payout);
}
else if (foreignObject is PaymentGroup)
{
return(FinancialDependencyType.PaymentGroup);
}
else if (foreignObject is FinancialTransaction)
{
return(FinancialDependencyType.FinancialTransaction);
}
throw new NotImplementedException("Unidentified dependency encountered in GetFinancialDependencyType:" +
foreignObject.GetType().ToString());
}
public static ObjectOptionalData ForObject(IHasIdentity identifiableObject)
{
ObjectOptionalData thisObject = FromBasic(SwarmDb.GetDatabaseForReading().GetObjectOptionalData((IHasIdentity)identifiableObject));
thisObject.forObject = identifiableObject;
return(thisObject);
}
public BasicChurnDataPoint[] GetChurnDataForOrganization(IHasIdentity organization, DateTime lowerDate,
DateTime upperDate)
{
// Since I don't trust SQL Server to make correct date comparisons, especially given
// that the dates are passed in text in SQL, we get ALL the data and do
// the comparison in code instead. This is a run-seldom function, anyway, and getting
// some 30k records with two unlinked fields isn't that expensive.
DateTime minimumDateTime = lowerDate.Date;
DateTime maximumDateTime = upperDate.Date.AddDays(1);
List <BasicChurnDataPoint> result = new List <BasicChurnDataPoint>();
BasicChurnDataPoint[] rawData = this.GetChurnData(organization);
foreach (BasicChurnDataPoint churnPoint in rawData)
{
// It is important that the lower border is inclusive and the upper exclusive in this
// comparison:
if (churnPoint.ExpiryDate >= minimumDateTime && churnPoint.ExpiryDate < maximumDateTime)
{
result.Add(churnPoint);
}
}
return(result.ToArray());
}
public BasicChurnDataPoint[] GetChurnDataForOrganization (IHasIdentity organization, DateTime lowerDate,
DateTime upperDate)
{
// Since I don't trust SQL Server to make correct date comparisons, especially given
// that the dates are passed in text in SQL, we get ALL the data and do
// the comparison in code instead. This is a run-seldom function, anyway, and getting
// some 30k records with two unlinked fields isn't that expensive.
DateTime minimumDateTime = lowerDate.Date;
DateTime maximumDateTime = upperDate.Date.AddDays(1);
List<BasicChurnDataPoint> result = new List<BasicChurnDataPoint>();
BasicChurnDataPoint[] rawData = this.GetChurnData(organization);
foreach (BasicChurnDataPoint churnPoint in rawData)
{
// It is important that the lower border is inclusive and the upper exclusive in this
// comparison:
if (churnPoint.ExpiryDate >= minimumDateTime && churnPoint.ExpiryDate < maximumDateTime)
{
result.Add(churnPoint);
}
}
return result.ToArray();
}
protected void Page_Load(object sender, EventArgs e)
{
_transaction = GetTransaction();
if (!_authority.HasPermission(Permission.CanSeeEconomyTransactions, _transaction.OrganizationId, -1, Authorization.Flag.ExactOrganization))
{
throw new UnauthorizedAccessException("Access Denied");
}
if (!Page.IsPostBack)
{
// Populate all data
this.DatePicker.DateInput.Culture = new CultureInfo("sv-SE");
this.DatePicker.SelectedDate = _transaction.DateTime;
this.TextDescription.Text = _transaction.Description;
this.TextDescription.Style.Add(HtmlTextWriterStyle.Width, "100%");
PopulateGrid();
PopulateEvents();
IHasIdentity dependency = _transaction.Dependency;
}
Documents documents = _transaction.Documents;
Page.Title = "Auditing Transaction #" + _transaction.Identity.ToString();
}
public BasicMembership[] GetExpiringMemberships(IHasIdentity organization, DateTime lowerBound, DateTime upperBound, DatabaseCondition condition)
{
// Since I don't trust SQL Server to make correct date comparisons, especially given
// that the dates are passed in text in SQL, we get ALL the memberships and do
// the comparison in code instead. This is a run-seldom function, anyway, and getting
// some 50k records with four short unlinked fields isn't that expensive.
BasicMembership[] memberships = this.GetMemberships(organization, condition);
DateTime minimumDateTime = lowerBound.Date;
DateTime maximumDateTime = upperBound.Date.AddDays(1);
List <BasicMembership> result = new List <BasicMembership>();
foreach (BasicMembership membership in memberships)
{
// It is important that the lower border is inclusive and the upper exclusive in this
// comparison:
if (membership.Expires >= minimumDateTime && membership.Expires < maximumDateTime)
{
result.Add(membership);
}
}
return(result.ToArray());
}
public static FinancialValidations ForObject(IHasIdentity financialDependency)
{
return
(FromArray(SwarmDb.GetDatabaseForReading()
.GetFinancialValidations(GetDependencyType(financialDependency),
financialDependency.Identity)));
}
public static void Create(FinancialValidationType validationType, IHasIdentity foreignObject,
Person actingPerson, double amount)
{
SwarmDb.GetDatabaseForWriting()
.CreateFinancialValidation(validationType, GetDependencyType(foreignObject), foreignObject.Identity,
DateTime.Now, actingPerson.Identity, amount);
}
public void SetForeignObjectForAll(IHasIdentity foreignObject)
{
foreach (Document doc in this)
{
doc.SetForeignObject(foreignObject);
}
}
private static ObjectType GetObjectTypeForObject(IHasIdentity objectToIdentify)
{
//string objectTypeString = objectToIdentify.GetType().ToString();
//// Strip namespace
//int lastPeriodIndex = objectTypeString.LastIndexOf('.');
//objectTypeString = objectTypeString.Substring(lastPeriodIndex + 1);
string objectTypeString = objectToIdentify.GetType().Name;
// At this point, we should be able to cast the string to an ObjectType enum
try
{
return((ObjectType)Enum.Parse(typeof(ObjectType), objectTypeString));
}
catch
{
//That failed. This could be a subclass, try upwards.
Type parentType = objectToIdentify.GetType().BaseType;
while (parentType != typeof(Object))
{
try
{
return((ObjectType)Enum.Parse(typeof(ObjectType), parentType.Name));
}
catch
{
parentType = parentType.BaseType;
}
}
}
throw new InvalidCastException("GetObjectTypeForObject could not identify object of type " +
objectToIdentify.GetType().Name);
}
internal static object FromBasic(IHasIdentity basic)
{
MethodInfo basicConverterMethod = null;
Type basicType = basic.GetType();
if (_converterLookup.ContainsKey(basicType))
{
basicConverterMethod = _converterLookup[basicType];
}
else
{
Assembly logicAssembly = typeof(SingularFactory).Assembly;
Assembly basicAssembly = typeof(BasicPerson).Assembly;
System.Type[] logicTypes =
logicAssembly.GetTypes().Where(type => type.IsSubclassOf(basicType)).ToArray();
if (logicTypes.Length > 1)
{
throw new InvalidOperationException("More than one type in Swarmops.Logic derives from " +
basicType.ToString());
}
if (logicTypes.Length == 0)
{
// There are no matching types in Swarmops.Logic; look through registered assemblies
foreach (Assembly foreignAssembly in _assemblyLookup.Values)
{
logicTypes = foreignAssembly.GetTypes().Where(type => type.IsSubclassOf(basicType)).ToArray();
if (logicTypes.Length == 1)
{
break;
}
}
if (logicTypes.Length == 0)
{
throw new InvalidOperationException(
"Unable to find higher-order class for base type " + basicType.ToString() + "; if it's in a plugin, was the higher-order assembly registered with SingularFactory?");
}
}
Type logicType = logicTypes[0];
basicConverterMethod = logicType.GetMethod("FromBasic", BindingFlags.Static | BindingFlags.Public);
if (basicConverterMethod == null)
{
throw new InvalidOperationException(
"Unable to find a public static method named \"" + logicType.ToString() + ".FromBasic (" + basicType.ToString() + ")\" in a loaded assembly");
}
_converterLookup[basicType] = basicConverterMethod;
}
object result = basicConverterMethod.Invoke(null, new object[] { basic });
return(result);
}
public static Document Create (string serverFileName, string clientFileName, Int64 fileSize,
string description, IHasIdentity identifiableObject, Person uploader)
{
int newDocumentId = SwarmDb.GetDatabaseForWriting().
CreateDocument(serverFileName, clientFileName, fileSize, description, GetDocumentTypeForObject(identifiableObject), identifiableObject == null? 0: identifiableObject.Identity, uploader.Identity);
return FromIdentityAggressive(newDocumentId);
}
public static Document Create(string serverFileName, string clientFileName, Int64 fileSize,
string description, IHasIdentity identifiableObject, Person uploader)
{
int newDocumentId = SwarmDb.GetDatabaseForWriting().
CreateDocument(serverFileName, clientFileName, fileSize, description, GetDocumentTypeForObject(identifiableObject), identifiableObject == null? 0: identifiableObject.Identity, uploader.Identity);
return(FromIdentityAggressive(newDocumentId));
}
public static FinancialTransactions ForDependentObject(IHasIdentity foreignObject)
{
return
(FromArray(
SwarmDb.GetDatabaseForReading()
.GetDependentFinancialTransactions(GetDependencyType(foreignObject),
foreignObject.Identity)));
}
public void CreateAffectedObject(IHasIdentity affectedObject)
{
string className = affectedObject.GetType().ToString();
int dotIndex = className.LastIndexOf('.');
className = className.Substring(dotIndex + 1); // assumes there's always at least one dot in a class name
SwarmDb.GetDatabaseForWriting().CreateSwarmopsLogEntryAffectedObject(this.Identity, className, affectedObject.Identity);
}
public void CreateAffectedObject (IHasIdentity affectedObject)
{
string className = affectedObject.GetType().ToString();
int dotIndex = className.LastIndexOf('.');
className = className.Substring(dotIndex + 1); // assumes there's always at least one dot in a class name
SwarmDb.GetDatabaseForWriting().CreateSwarmopsLogEntryAffectedObject(this.Identity, className, affectedObject.Identity);
}
private static string GetObjectDetails(IHasIdentity identifiableObject)
{
switch (identifiableObject.GetType().Name)
{
case "ExpenseClaim":
ExpenseClaim claim = (ExpenseClaim)identifiableObject;
return("<strong>" +
String.Format(Global.Financial_ExpenseClaimLongSpecification, claim.Identity) +
":</strong> " + claim.Organization.Currency.Code + " " +
(claim.AmountCents / 100.0).ToString("N2") + ". " +
HttpUtility.HtmlEncode(GetValidationDetails(claim.Validations)) + " " +
GetDocumentDetails(claim.Documents, claim));
case "CashAdvance":
CashAdvance advance = (CashAdvance)identifiableObject;
return("<strong>" +
String.Format(Global.Financial_CashAdvanceSpecification, advance.Identity) +
":</strong> " + advance.Organization.Currency.Code + " " +
(advance.AmountCents / 100.0).ToString("N2") + ". " +
HttpUtility.HtmlEncode(GetValidationDetails(advance.Validations)));
case "InboundInvoice":
InboundInvoice invoice = (InboundInvoice)identifiableObject;
return("<strong>" +
String.Format(Global.Financial_InboundInvoiceSpecification, invoice.Identity) +
":</strong> " + invoice.Organization.Currency.Code + " " +
(invoice.AmountCents / 100.0).ToString("N2") + ". " +
GetValidationDetails(invoice.Validations) + " " +
GetDocumentDetails(invoice.Documents, invoice));
case "Salary":
Salary salary = (Salary)identifiableObject;
return("<strong>" +
String.Format(Global.Financial_SalaryIdentity, salary.Identity) +
":</strong> " +
String.Format(Resources.Pages.Ledgers.InspectLedgers_TxDetail_SalaryDetail,
salary.PayrollItem.Organization.Currency.Code,
salary.BaseSalaryCents / 100.0, // base salary
(salary.GrossSalaryCents - salary.BaseSalaryCents) / 100.0, // before-tax adjustments
salary.GrossSalaryCents / 100.0, // before-tax adjusted salary
salary.SubtractiveTaxCents / 100.0, // tax deduction
(salary.NetSalaryCents + salary.SubtractiveTaxCents -
salary.GrossSalaryCents) / 100.0, // after-tax adjustments
salary.NetSalaryCents / 100.0) + // actual payout amount
" " + GetValidationDetails(salary.Validations));
default:
throw new NotImplementedException("Unhandled object type in GetObjectDetails: " +
identifiableObject.GetType().Name);
}
}
public static Documents ForObject(IHasIdentity identifiableObject)
{
Documents newInstance =
FromArray(
SwarmDb.GetDatabaseForReading().GetDocumentsForForeignObject(
Document.GetDocumentTypeForObject(identifiableObject), identifiableObject.Identity));
newInstance.sourceObject = identifiableObject;
return(newInstance);
}
protected void Page_Load(object sender, EventArgs e)
{
_transaction = GetTransaction();
if (!_authority.HasPermission(Permission.CanDoEconomyTransactions, _transaction.OrganizationId, -1, Authorization.Flag.ExactOrganization))
{
throw new UnauthorizedAccessException("Access Denied");
}
if (!Page.IsPostBack)
{
// Populate all data
this.DatePicker.DateInput.Culture = new CultureInfo("sv-SE");
this.DatePicker.SelectedDate = _transaction.DateTime;
this.TextDescription.Text = _transaction.Description;
this.TextDescription.Style.Add(HtmlTextWriterStyle.Width, "100%");
this.TextAmount.Style.Add(HtmlTextWriterStyle.Width, "80px");
this.DropAccounts.Style.Add(HtmlTextWriterStyle.Width, "200px");
this.TextAmount.Text = (-_transaction.Rows.AmountTotal).ToString("N2", new CultureInfo("sv-SE"));
PopulateAccounts(_transaction.OrganizationId);
PopulateGrid();
IHasIdentity dependency = _transaction.Dependency;
if (dependency != null)
{
this.PanelModifiableTransaction.Visible = false;
this.PanelUnmodifiableTransaction.Visible = true;
if (dependency is ExpenseClaim)
{
this.LabelDependency.Text = "Expense Claim #" + dependency.Identity.ToString();
this.PanelDependencyDocuments.Visible = true;
this.DocumentsDependency.Documents = Documents.ForObject(dependency);
}
else if (dependency is Payout)
{
this.PanelDependencyDocuments.Visible = false;
this.PanelPayoutDetails.Visible = true;
this.LabelDependency.Text = "Payout #" + dependency.Identity.ToString();
this.LabelPayoutIdentity.Text = dependency.Identity.ToString();
this.LabelPayoutReference.Text = ((Payout)dependency).Reference;
}
}
}
this.DocumentList.Documents = _transaction.Documents;
Page.Title = "Editing Transaction #" + _transaction.Identity.ToString();
}
public static Payout FromDependency(IHasIdentity dependency)
{
int payoutId = SwarmDb.GetDatabaseForReading().GetPayoutIdFromDependency(dependency);
if (payoutId == 0)
{
throw new ArgumentException("Supplied item does not have an associated payout");
}
return(Payout.FromIdentity(payoutId));
}
internal static int[] ObjectsToIdentifiers (IHasIdentity[] identifiables)
{
var result = new List<int>();
result.Capacity = identifiables.Length*11/10;
foreach (IHasIdentity identifiable in identifiables)
{
result.Add (identifiable.Identity);
}
return result.ToArray();
}
private void AddValidations(int parentId, IHasIdentity validatableObject)
{
FinancialValidations validations = FinancialValidations.ForObject(validatableObject);
foreach (FinancialValidation validation in validations)
{
transactionEvents.Add(
new TransactionEvent(transactionEvents.Count + 1, parentId,
validation.ValidationType + " by " + validation.Person.Canonical + " at " +
validation.DateTime.ToString("yyyy-MM-dd HH:mm")));
}
}
public AttestableItem(string identity, string beneficiary, Int64 amountCents, FinancialAccount account,
string description, string identityDisplay, bool hasDox, IHasIdentity item)
{
IdentityDisplay = identityDisplay;
Identity = identity;
Beneficiary = beneficiary;
AmountRequestedCents = amountCents;
Budget = account;
Description = description;
HasDox = hasDox;
Item = item;
}
private static FinancialDependencyType GetDependencyType(IHasIdentity foreignObject)
{
if (foreignObject is ExpenseClaim)
{
return(FinancialDependencyType.ExpenseClaim);
}
if (foreignObject is InboundInvoice)
{
return(FinancialDependencyType.InboundInvoice);
}
throw new NotImplementedException("Unimplemented dependency type:" + foreignObject.GetType());
}
/// <summary>
/// Returns a detailed string representation of this transaction.
/// </summary>
/// <returns>A detailed string representation of this transaction.</returns>
public string Detail()
{
string tagString = "";
IHasIdentity tag = m_tag as IHasIdentity;
if (tag != null)
{
tagString = ", " + tag.Name + "(" + tag.Guid + ")";
}
return(When + " : " + (m_resource == null?"<unknown>":m_resource.Name) + ", " + m_quantityObtained
+ ", " + m_quantityDesired + ", " + m_capacity + ", " + Available + ", "
+ (Requester == null?"<unknown>":Requester.Name) + ", " + Action + tagString);
}
public bool CanAccess(IHasIdentity identifiableObject, AccessType accessType = AccessType.Write)
{
// Tests if this Authority can access a certain object. Add new object types as needed by the logic.
// This is a very general case of the CanSeePerson() function.
PositionAssignment testAssignment = identifiableObject as PositionAssignment;
if (testAssignment != null)
{
// shortcut, for now
return(HasSystemAccess(accessType));
}
throw new NotImplementedException("Authority.CanAccess is not implemented for type " + identifiableObject.GetType().FullName);
}
private static string GetDocumentDetails(Documents documents, IHasIdentity identifiableObject)
{
string docLink = string.Empty;
string objectIdString = identifiableObject.GetType().Name + identifiableObject.Identity;
foreach (Document document in documents)
{
docLink += "<a href='/Pages/v5/Support/StreamUpload.aspx?DocId=" + document.Identity +
"' class='FancyBox_Gallery' rel='" + objectIdString + "'> </a>";
}
return("Documents were uploaded by " + documents[0].UploadedByPerson.Canonical + " at " +
documents[0].UploadedDateTime.ToString("yyyy-MMM-dd HH:mm") +
". <a href='#' class='linkViewDox' objectId='" + objectIdString +
"'>View documents.</a><span class='hiddenDocLinks'>" + docLink + "</span>");
}
public static object FromBasic(IHasIdentity basic)
{
// ASSUMPTION: We're assuming that the type to be created exists in the "Logic" assembly, and that we can bind permanently in a lookup
MethodInfo basicConverterMethod = null;
Type basicType = basic.GetType();
if (_converterLookup.ContainsKey(basicType))
{
basicConverterMethod = _converterLookup[basicType];
}
else
{
Assembly logicAssembly = typeof(SingularFactory).Assembly;
Assembly basicAssembly = typeof(BasicPerson).Assembly;
System.Type[] logicTypes =
logicAssembly.GetTypes().Where(type => type.IsSubclassOf(basicType)).ToArray();
if (logicTypes.Length > 1)
{
throw new InvalidOperationException("More than one type in Swarmops.Logic derives from " +
basicType.ToString());
}
if (logicTypes.Length == 0)
{
throw new InvalidOperationException(
"Unable to find higher-order class in Swarmops.Logic for base type " + basicType.ToString());
}
Type logicType = logicTypes[0];
basicConverterMethod = logicType.GetMethod("FromBasic", BindingFlags.Static | BindingFlags.Public);
if (basicConverterMethod == null)
{
throw new InvalidOperationException(
"Unable to find a public static method named \"" + logicType.ToString() + ".FromBasic (" + basicType.ToString() + ")\" in the Swarmops.Logic assembly");
}
_converterLookup[basicType] = basicConverterMethod;
}
object result = basicConverterMethod.Invoke(null, new object[] { basic });
return(result);
}
public void SetObjectOptionalData(IHasIdentity thisObject, ObjectOptionalDataType dataType, string data)
{
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command = GetDbCommand("SetObjectOptionalData", connection);
command.CommandType = CommandType.StoredProcedure;
AddParameterWithName(command, "objectType", GetObjectTypeForObject(thisObject).ToString());
AddParameterWithName(command, "objectId", thisObject.Identity);
AddParameterWithName(command, "objectOptionalDataType", dataType.ToString());
AddParameterWithName(command, "data", data);
command.ExecuteNonQuery();
}
}
public BasicAuthority GetPersonAuthority(IHasIdentity person)
{
List <BasicPersonRole> systemRoles = new List <BasicPersonRole>();
List <BasicPersonRole> organizationRoles = new List <BasicPersonRole>();
List <BasicPersonRole> localRoles = new List <BasicPersonRole>();
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command =
GetDbCommand("SELECT " + personRoleFieldSequence + ConstructWhereClause("PersonRoles", person),
connection);
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
BasicPersonRole newPersonRole = ReadPersonRoleFromDataReader(reader);
switch (RoleTypes.ClassOfRole(newPersonRole.Type))
{
case RoleClass.System:
systemRoles.Add(newPersonRole);
break;
case RoleClass.Organization:
organizationRoles.Add(newPersonRole);
break;
case RoleClass.Local:
localRoles.Add(newPersonRole);
break;
default:
throw new InvalidOperationException("Invalid RoleTypeId (" + newPersonRole.Type +
") in database for PersonId " +
person.Identity.ToString());
}
}
return(new BasicAuthority(person.Identity, systemRoles.ToArray(), organizationRoles.ToArray(),
localRoles.ToArray()));
}
}
}
static FinancialDependencyType GetDependencyType(IHasIdentity foreignObject)
{
if (foreignObject is ExpenseClaim)
{
return(FinancialDependencyType.ExpenseClaim);
}
if (foreignObject is InboundInvoice)
{
return(FinancialDependencyType.InboundInvoice);
}
if (foreignObject is Salary)
{
return(FinancialDependencyType.Salary);
}
throw new NotImplementedException("Unknown dependency: " + foreignObject.GetType().ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="MaterialResourceRequest"/> class.
/// </summary>
/// <param name="byWhom">The identity of the entity making the reqest.</param>
/// <param name="mt">The Material Type being requested.</param>
/// <param name="materialSpecs">The material specs, if any, being requested. Note: See the tech note on Material Specifications.</param>
/// <param name="quantity">The quantity of Material being requested.</param>
/// <param name="direction">The <see cref="MaterialResourceRequest.Direction "/> of the request - Augment or Deplete.</param>
public MaterialResourceRequest(IHasIdentity byWhom, MaterialType mt, ICollection materialSpecs, double quantity, Direction direction)
{
AsyncGrantConfirmationCallback = DefaultGrantConfirmationRequest_Refuse;
Status = RequestStatus.Free;
Replicate = DefaultReplicator;
Requester = byWhom;
m_materialType = mt;
m_materialSpecs = materialSpecs ?? new ArrayList();
if (direction.Equals(Direction.Deplete))
{
m_quantityDesired = quantity;
}
else
{
m_quantityDesired = -quantity;
}
}
public BasicAuthority GetPersonAuthority (IHasIdentity person)
{
List<BasicPersonRole> systemRoles = new List<BasicPersonRole>();
List<BasicPersonRole> organizationRoles = new List<BasicPersonRole>();
List<BasicPersonRole> localRoles = new List<BasicPersonRole>();
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command = GetDbCommand("SELECT " + personRoleFieldSequence + ConstructWhereClause("PersonRoles", person),
connection);
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
BasicPersonRole newPersonRole = ReadPersonRoleFromDataReader(reader);
switch (RoleTypes.ClassOfRole(newPersonRole.Type))
{
case RoleClass.System:
systemRoles.Add(newPersonRole);
break;
case RoleClass.Organization:
organizationRoles.Add(newPersonRole);
break;
case RoleClass.Local:
localRoles.Add(newPersonRole);
break;
default:
throw new InvalidOperationException("Invalid RoleTypeId (" + newPersonRole.Type +
") in database for PersonId " + person.Identity.ToString());
}
}
return new BasicAuthority(person.Identity, systemRoles.ToArray(), organizationRoles.ToArray(),
localRoles.ToArray());
}
}
}
public static Payout FromDependency(IHasIdentity dependency, FinancialDependencyType dependencyType = FinancialDependencyType.Unknown)
{
int payoutId = 0;
if (dependencyType == FinancialDependencyType.Unknown)
{
payoutId = SwarmDb.GetDatabaseForReading().GetPayoutIdFromDependency(dependency);
}
else
{
payoutId = SwarmDb.GetDatabaseForReading().GetPayoutIdFromDependency(dependency, dependencyType);
}
if (payoutId == 0)
{
throw new ArgumentException("Supplied item does not have an associated payout");
}
return(Payout.FromIdentity(payoutId));
}
public static VatReportItem Create(VatReport report, FinancialTransaction transaction, Int64 turnoverCents,
Int64 vatInboundCents, Int64 vatOutboundCents)
{
// Assumes there's a dependency of some sort
IHasIdentity foreignObject = transaction.Dependency;
FinancialDependencyType dependencyType =
(foreignObject != null
? FinancialTransaction.GetFinancialDependencyType(transaction.Dependency)
: FinancialDependencyType.Unknown);
// The transaction dependency is stored for quick lookup; it duplicates information in the database
// to save an expensive query as a mere optimization.
int newVatReportItemId = SwarmDb.GetDatabaseForWriting()
.CreateVatReportItem(report.Identity, transaction.Identity, foreignObject?.Identity ?? 0,
dependencyType, turnoverCents, vatInboundCents, vatOutboundCents);
return(FromIdentityAggressive(newVatReportItemId));
}
public static DocumentType GetDocumentTypeForObject (IHasIdentity foreignObject)
{
if (foreignObject == null)
{
// docs uploaded; foreign object not yet constructed
return DocumentType.Unknown;
}
else if (foreignObject is Person)
{
return DocumentType.PersonPhoto;
}
else if (foreignObject is ExpenseClaim)
{
return DocumentType.ExpenseClaim;
}
else if (foreignObject is FinancialTransaction)
{
return DocumentType.FinancialTransaction;
}
else if (foreignObject is TemporaryIdentity)
{
return DocumentType.Temporary;
}
else if (foreignObject is InboundInvoice)
{
return DocumentType.InboundInvoice;
}
else if (foreignObject is PaperLetter)
{
return DocumentType.PaperLetter;
}
else if (foreignObject is ExternalActivity)
{
return DocumentType.ExternalActivityPhoto;
}
else
{
throw new ArgumentException("Unrecognized foreign object type:" + foreignObject.GetType().ToString());
}
}
private static string GetWhereClauseForObject (IHasIdentity foreignObject)
{
// This is kind of dangerous and assumes that foreignObject has the same TYPE NAME,
// including casing, as part of the DATABASE FIELD used for primary key.
// Also, it shifts the burden of error from the logic layer with hard function
// typing ("no such function: ForOrganization") at compile time, to the database layer
// ("No such field: OrganizationId") at runtime.
// As such, it is not a good design choice for robustness, but a good design choice
// for quick developability and expandability, as it reduces plumbing considerably.
// Example: for an object of type Person with Identity 4711, this returns " PersonId=4711 ".
if (foreignObject == null)
{
return string.Empty;
}
return " " + GetForeignTypeString(foreignObject) + "Id=" + foreignObject.Identity.ToString() + " ";
}
public BasicObjectOptionalData GetObjectOptionalData (IHasIdentity forObject)
{
Dictionary<ObjectOptionalDataType, string> initialData = new Dictionary<ObjectOptionalDataType, string>();
ObjectType objectType = GetObjectTypeForObject(forObject);
int objectId = forObject.Identity;
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command =
GetDbCommand(
"SELECT" + objectOptionalDataFieldSequence + "WHERE ObjectTypes.Name='" + objectType.ToString() + "' " +
"AND ObjectOptionalData.ObjectId=" + objectId.ToString() + ";", connection);
using (DbDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
string objectOptionalDataTypeString = reader.GetString(2);
string data = reader.GetString(3);
try
{
ObjectOptionalDataType objectOptionalDataType =
(ObjectOptionalDataType)
Enum.Parse(typeof(ObjectOptionalDataType), objectOptionalDataTypeString);
initialData[objectOptionalDataType] = data;
}
catch (Exception)
{
// Ignore unknown enums at this point - too many disconnects between v4 and v5 -Rick
}
}
return new BasicObjectOptionalData(objectType, objectId, initialData);
}
}
}
public int GetPayoutIdFromDependency(IHasIdentity foreignObject)
{
return GetPayoutIdFromDependency(foreignObject.Identity, GetForeignTypeString(foreignObject));
}
static private FinancialDependencyType GetFinancialDependencyType (IHasIdentity foreignObject)
{
if (foreignObject is ExpenseClaim)
{
return FinancialDependencyType.ExpenseClaim;
}
else if (foreignObject is InboundInvoice)
{
return FinancialDependencyType.InboundInvoice;
}
else if (foreignObject is OutboundInvoice)
{
return FinancialDependencyType.OutboundInvoice;
}
else if (foreignObject is Salary)
{
return FinancialDependencyType.Salary;
}
else if (foreignObject is Payout)
{
return FinancialDependencyType.Payout;
}
else if (foreignObject is PaymentGroup)
{
return FinancialDependencyType.PaymentGroup;
}
else if (foreignObject is FinancialTransaction)
{
return FinancialDependencyType.FinancialTransaction;
}
throw new NotImplementedException("Unidentified dependency encountered in GetFinancialDependencyType:" +
foreignObject.GetType().ToString());
}
public static FinancialTransaction FromDependency(IHasIdentity dependency)
{
return FromBasic(SwarmDb.GetDatabaseForReading().GetFinancialTransactionFromDependency(dependency));
}
public void SetForeignObject (IHasIdentity foreignObject)
{
SwarmDb.GetDatabaseForWriting().SetDocumentForeignObject(this.Identity, GetDocumentTypeForObject(foreignObject), foreignObject.Identity);
}
public static ObjectOptionalData ForObject (IHasIdentity identifiableObject)
{
ObjectOptionalData thisObject = FromBasic(SwarmDb.GetDatabaseForReading().GetObjectOptionalData((IHasIdentity)identifiableObject));
thisObject.forObject = identifiableObject;
return thisObject;
}
public BasicMembership[] GetExpiringMemberships (IHasIdentity organization, DateTime lowerBound, DateTime upperBound)
{
return GetExpiringMemberships(organization, lowerBound, upperBound, DatabaseCondition.ActiveTrue);
}
public BasicFinancialTransaction GetFinancialTransactionFromDependency (IHasIdentity foreignObject)
{
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
string commandString = "SELECT FinancialTransactionId FROM FinancialTransactionDependencies " +
"JOIN FinancialDependencyTypes ON (FinancialDependencyTypes.FinancialDependencyTypeId=FinancialTransactionDependencies.FinancialDependencyTypeId) " +
"WHERE FinancialDependencyTypes.Name='" + GetForeignTypeString(foreignObject) +
"' AND FinancialTransactionDependencies.ForeignId=" + foreignObject.Identity + ";";
DbCommand command = GetDbCommand(commandString, connection);
using (DbDataReader reader = command.ExecuteReader())
{
if (reader.Read())
{
return GetFinancialTransaction(reader.GetInt32(0)); // Warning: opens another datareader before closing both
}
throw new ArgumentException(
String.Format("No financial transaction for specified dependency: {0} #{1}",
GetForeignTypeString(foreignObject), foreignObject.Identity));
}
}
}
static private ObjectType GetObjectTypeForObject (IHasIdentity objectToIdentify)
{
//string objectTypeString = objectToIdentify.GetType().ToString();
//// Strip namespace
//int lastPeriodIndex = objectTypeString.LastIndexOf('.');
//objectTypeString = objectTypeString.Substring(lastPeriodIndex + 1);
string objectTypeString = objectToIdentify.GetType().Name;
// At this point, we should be able to cast the string to an ObjectType enum
try
{
return (ObjectType)Enum.Parse(typeof(ObjectType), objectTypeString);
}
catch
{
//That failed. This could be a subclass, try upwards.
Type parentType = objectToIdentify.GetType().BaseType;
while (parentType != typeof(Object))
{
try
{
return (ObjectType)Enum.Parse(typeof(ObjectType), parentType.Name);
}
catch
{
parentType = parentType.BaseType;
}
}
}
throw new InvalidCastException("GetObjectTypeForObject could not identify object of type " + objectToIdentify.GetType().Name);
}
public void SetObjectOptionalData (IHasIdentity thisObject, ObjectOptionalDataType dataType, string data)
{
using (DbConnection connection = GetMySqlDbConnection())
{
connection.Open();
DbCommand command = GetDbCommand("SetObjectOptionalData", connection);
command.CommandType = CommandType.StoredProcedure;
AddParameterWithName(command, "objectType", GetObjectTypeForObject(thisObject).ToString());
AddParameterWithName(command, "objectId", thisObject.Identity);
AddParameterWithName(command, "objectOptionalDataType", dataType.ToString());
AddParameterWithName(command, "data", data);
command.ExecuteNonQuery();
}
}
public int GetPayoutIdFromDependency(IHasIdentity foreignObject, FinancialDependencyType typeName)
{
return GetPayoutIdFromDependency(foreignObject.Identity, typeName.ToString());
}
private static string GetForeignTypeString (IHasIdentity foreignObject)
{
string typeString = "";
foreach (object attribute in foreignObject.GetType().GetCustomAttributes(typeof(DbRecordType), true))
{
if (attribute is DbRecordType)
{
typeString = ((DbRecordType)attribute).TypeName;
}
}
if (typeString == "")
{
typeString = foreignObject.GetType().ToString();
if (typeString.Contains("."))
{
int periodIndex = typeString.LastIndexOf('.');
typeString = typeString.Substring(periodIndex + 1);
}
}
return typeString;
}
public BasicMembership[] GetExpiringMemberships (IHasIdentity organization, DateTime expiry)
{
return GetExpiringMemberships(organization, expiry, expiry);
}
public BasicMembership[] GetExpiringMemberships (IHasIdentity organization, DateTime lowerBound, DateTime upperBound, DatabaseCondition condition)
{
// Since I don't trust SQL Server to make correct date comparisons, especially given
// that the dates are passed in text in SQL, we get ALL the memberships and do
// the comparison in code instead. This is a run-seldom function, anyway, and getting
// some 50k records with four short unlinked fields isn't that expensive.
BasicMembership[] memberships = this.GetMemberships(organization, condition);
DateTime minimumDateTime = lowerBound.Date;
DateTime maximumDateTime = upperBound.Date.AddDays(1);
List<BasicMembership> result = new List<BasicMembership>();
foreach (BasicMembership membership in memberships)
{
// It is important that the lower border is inclusive and the upper exclusive in this
// comparison:
if (membership.Expires >= minimumDateTime && membership.Expires < maximumDateTime)
{
result.Add(membership);
}
}
return result.ToArray();
}
private void AddValidations (int parentId, IHasIdentity validatableObject)
{
FinancialValidations validations = FinancialValidations.ForObject(validatableObject);
foreach (FinancialValidation validation in validations)
{
transactionEvents.Add(
new TransactionEvent(transactionEvents.Count + 1, parentId,
validation.ValidationType + " by " + validation.Person.Canonical + " at " +
validation.DateTime.ToString("yyyy-MM-dd HH:mm")));
}
}
static public object FromBasic(IHasIdentity basic)
{
string argumentType = basic.GetType().ToString();
switch (argumentType)
{
// ----- Is there any way to make self-writing code here through replication or similar, so
// ----- that every case doesn't need to be listed?
// ------------ COMMUNICATION CLASSES ------------
case "Swarmops.Basic.Types.BasicCommunicationTurnaround":
return CommunicationTurnaround.FromBasic((BasicCommunicationTurnaround)basic);
case "Swarmops.Basic.Types.Communications.BasicOutboundComm":
return OutboundComm.FromBasic((BasicOutboundComm)basic);
case "Swarmops.Basic.Types.Communications.BasicOutboundCommRecipient":
return OutboundCommRecipient.FromBasic((BasicOutboundCommRecipient)basic);
// ----------- FINANCIAL CLASSES ----------
case "Swarmops.Basic.Types.BasicExpenseClaim":
return ExpenseClaim.FromBasic((BasicExpenseClaim)basic);
case "Swarmops.Basic.Types.Financial.BasicCashAdvance":
return CashAdvance.FromBasic((BasicCashAdvance)basic);
case "Swarmops.Basic.Types.BasicInboundInvoice":
return InboundInvoice.FromBasic((BasicInboundInvoice) basic);
case "Swarmops.Basic.Types.Financial.BasicFinancialAccount":
return FinancialAccount.FromBasic((BasicFinancialAccount)basic);
case "Swarmops.Basic.Types.Financial.BasicFinancialTransaction":
return FinancialTransaction.FromBasic((BasicFinancialTransaction)basic);
case "Swarmops.Basic.Types.BasicFinancialValidation":
return FinancialValidation.FromBasic((BasicFinancialValidation)basic);
case "Swarmops.Basic.Types.BasicOutboundInvoice":
return OutboundInvoice.FromBasic((BasicOutboundInvoice)basic);
case "Swarmops.Basic.Types.BasicOutboundInvoiceItem":
return OutboundInvoiceItem.FromBasic((BasicOutboundInvoiceItem)basic);
case "Swarmops.Basic.Types.BasicPayment":
return Payment.FromBasic((BasicPayment)basic);
case "Swarmops.Basic.Types.BasicPaymentGroup":
return PaymentGroup.FromBasic((BasicPaymentGroup)basic);
case "Swarmops.Basic.Types.BasicPayout":
return Payout.FromBasic((BasicPayout)basic);
case "Swarmops.Basic.Types.BasicPayrollAdjustment":
return PayrollAdjustment.FromBasic((BasicPayrollAdjustment) basic);
case "Swarmops.Basic.Types.BasicPayrollItem":
return PayrollItem.FromBasic((BasicPayrollItem)basic);
case "Swarmops.Basic.Types.BasicSalary":
return Salary.FromBasic((BasicSalary) basic);
case "Swarmops.Basic.Types.Financial.BasicFinancialTransactionTagSet":
return FinancialTransactionTagSet.FromBasic ((BasicFinancialTransactionTagSet) basic);
case "Swarmops.Basic.Types.Financial.BasicFinancialTransactionTagType":
return FinancialTransactionTagType.FromBasic((BasicFinancialTransactionTagType) basic);
// ------------ GOVERNANCE CLASSES ------------
case "Swarmops.Basic.Types.BasicBallot":
return Ballot.FromBasic((BasicBallot)basic);
case "Swarmops.Basic.Types.BasicMeetingElectionCandidate":
return MeetingElectionCandidate.FromBasic((BasicInternalPollCandidate)basic);
case "Swarmops.Basic.Types.BasicMeetingElection":
return MeetingElection.FromBasic((BasicInternalPoll)basic);
case "Swarmops.Basic.Types.BasicMeetingElectionVote":
return MeetingElectionVote.FromBasic((BasicInternalPollVote)basic);
case "Swarmops.Basic.Types.Governance.BasicMotion":
return Motion.FromBasic((BasicMotion)basic);
case "Swarmops.Basic.Types.Governance.BasicMotionAmendment":
return MotionAmendment.FromBasic((BasicMotionAmendment)basic);
// ------------ PARLEY/ACTIVISM CLASSES ------------
case "Swarmops.Basic.Types.BasicExternalActivity":
return ExternalActivity.FromBasic((BasicExternalActivity) basic);
case "Swarmops.Basic.Types.BasicParley":
return Parley.FromBasic((BasicParley)basic);
case "Swarmops.Basic.Types.BasicParleyAttendee":
return ParleyAttendee.FromBasic((BasicParleyAttendee)basic);
case "Swarmops.Basic.Types.BasicParleyOption":
return ParleyOption.FromBasic((BasicParleyOption)basic);
case "Swarmops.Basic.Types.BasicPerson":
return Person.FromBasic((BasicPerson)basic);
// ------------------ FAIL ----------------
default:
throw new NotImplementedException("Unimplemented argument type: " + argumentType);
}
}
