public void SelfServeReportGrant( )
{
IAccessRuleFactory accessRuleFactory;
IAccessRuleReportFactory accessRuleReportFactory;
Subject selfServeRole;
Solution coreDataSolution;
accessRuleReportFactory = new AccessRuleDisplayReportFactory( );
accessRuleFactory = new AccessRuleFactory( );
using (DatabaseContext databaseContext = DatabaseContext.GetContext(true))
using (new SecurityBypassContext( ))
{
selfServeRole = Entity.Get <Subject>("core:selfServeRole", true);
coreDataSolution = CodeNameResolver.GetInstance("ReadiNow Core Data", "Application").As <Solution>( );
// Allow the test to be rerun by re-enabling the allow all Administrators access rule
//EnableAdministratorAccessAllRule( );
// Create access rules
//DeleteAccessRules( ReportTypeNames, SelfServeCreateAccessRuleNameTemplate );
CreateAccessRules(
accessRuleFactory,
accessRuleReportFactory,
selfServeRole,
SelfServeTypeNames,
new [] { Permissions.Create },
"core:createSelfServeComponentsAccessRule",
coreDataSolution);
// Disable the "allow all" administrator access rule
//DisableAdministratorAccessAllRule( );
databaseContext.CommitTransaction( );
}
}
public void Test_Rollup_Report_On_EditForm()
{
using (new SecurityBypassContext())
{
var report = CodeNameResolver.GetInstance("AA_All Fields Rollup", "Report");
var typeId = Factory.ScriptNameResolver.GetTypeByName("AA_Herb");
var instance = CodeNameResolver.GetInstance("Basil", "AA_Herb");
var relationshipId = Factory.ScriptNameResolver.GetMemberOfType("AA_All Fields", typeId, MemberType.Relationship).MemberId;
ReportSettings settings = new ReportSettings
{
ReportRelationship = new ReportRelationshipSettings
{
EntityId = instance.Id,
RelationshipId = relationshipId,
Direction = ReportRelationshipSettings.ReportRelationshipDirection.Forward
},
RequireFullMetadata = true
};
var reportInterface = new ReportingInterface();
ReportResult result = reportInterface.RunReport(report.Id, null);
Assert.That(result, Is.Not.Null);
Assert.That(result.GridData, Has.Count.GreaterThan(0));
Assert.That(result.AggregateMetadata.Groups, Has.Count.EqualTo(2));
}
}
public void TestNSWPopulation()
{
var ireport = CodeNameResolver.GetInstance("NSW Population", "Report");
var report = ireport.As <Report>();
// Check report
CheckResourceReport(report, "Population", 5);
Assert.IsNotNull(report.RootNode.As <ResourceReportNode>());
// Check columns
var columns = report.ReportColumns.OrderBy(c => c.ColumnDisplayOrder).ToArray();
CheckIdColumn(columns[0], report.RootNode.Id);
CheckFieldColumn <DateArgument>(columns[1], "Month", "Month", report.RootNode);
CheckFieldColumn <IntegerArgument>(columns[2], "Male", "Male", report.RootNode);
CheckFieldColumn <IntegerArgument>(columns[3], "Female", "Female", report.RootNode);
CheckScriptColumn <IntegerArgument>(columns[4], "Combined", "Male+Female", report.RootNode);
// Check conditions
var conds = report.HasConditions.OrderBy(c => c.ConditionDisplayOrder).ToArray();
CheckCondition <StringArgument>(conds[0], "State"); // currently returning string field??
CheckCondition <DateArgument>(conds[1], "Month");
CheckCondition <IntegerArgument>(conds[2], "Male");
CheckCondition <IntegerArgument>(conds[3], "Female");
CheckCondition <IntegerArgument>(conds[4], "Calculation"); // "Calculation" is what's in the analyzer XML. No idea why it's showing "Combined" in SL instead??
Assert.AreEqual("NSW",
conds[0].ConditionParameter.ParamTypeAndDefault.As <StringArgument>().StringParameterValue);
}
public void TestGetFormData()
{
var employeeType = CodeNameResolver.GetTypeByName("AA_Employee").As <EntityType>();
var employeeForm = employeeType.DefaultEditForm;
var employee = Entity.GetInstancesOfType(employeeType).FirstOrDefault();
using (var request = new PlatformHttpRequest(@"data/v1/form/data", PlatformHttpMethod.Post))
{
FormDataRequest formDataRequest = new FormDataRequest
{
FormId = employeeForm.Id.ToString(),
EntityId = employee.Id.ToString(),
Query = "name, description"
};
request.PopulateBody(formDataRequest);
HttpWebResponse response = request.GetResponse();
var formDataResponse = request.DeserialiseResponseBody <FormDataResponse>();
Assert.IsNotNull(formDataResponse);
// check that it worked (200)
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
}
}
public void GetResourceByReport( )
{
var personReport = CodeNameResolver.GetInstance("AA_Person", "Report");
var getResources = new GetResourcesActivity( );
getResources.Save( );
//_toDelete.Add(getResources.Id);
var getResourcesAs = getResources.As <WfActivity>( );
ActivityImplementationBase nextActivity = getResourcesAs.CreateWindowsActivity( );
var args = new Dictionary <string, object>
{
{
"Report", personReport
},
};
IDictionary <string, object> result = RunActivity(nextActivity, args);
var list = result["List"] as IEnumerable <IEntity>;
var first = result["First"];
var personType = CodeNameResolver.GetTypeByName("AA_Person").As <EntityType>();
long countPeople = personType.GetDescendantsAndSelf().SelectMany(t => t.InstancesOfType).Select(i => i.Id).Distinct().Count();
Assert.IsNotNull(list);
Assert.AreEqual(list.Count( ), countPeople, "The count of people is correct");
}
public void CreateActivityRun()
{
var personType = CodeNameResolver.GetTypeByName("AA_Person").As <EntityType>();
const string createdRecordArgKey = "Record";
var createActivity = new CreateActivity();
createActivity.Save();
ToDelete.Add(createActivity.Id);
var nextActivity = (CreateImplementation)createActivity.As <WfActivity>().CreateWindowsActivity();
var inputs = new Dictionary <string, object>
{
{
"Object", personType
}
};
IDictionary <string, object> result = RunActivity(nextActivity, inputs);
Assert.AreEqual(2, result.Count, "There are two results, and exit point + a value");
Assert.IsTrue(result.ContainsKey(createdRecordArgKey));
var resourceId = (IEntity)result[createdRecordArgKey];
ToDelete.Add(resourceId.Id);
var person = Entity.Get(resourceId.Id);
Assert.IsNotNull(person, "We have a person");
}
public void LogEmployeesAge()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var wf = new Workflow()
{
Name = "Log Employees Age " + DateTime.Now
};
wf.AddDefaultExitPoint();
EntityType type = CodeNameResolver.GetTypeByName("AA_Employee").As <EntityType>();
wf.AddVariable <ResourceListArgument>("list", "all(AA_Employee)", type)
.AddForEach("foreach", "list", type)
.AddLog("Log", "{{foreach_Record.Age}}", "foreach", "Loop")
.AddTransition("Log", "foreach");
wf.Save();
var wfInput = new Dictionary <string, object>();
var run = (RunWorkflow(wf, wfInput));
Assert.AreEqual(WorkflowRunState_Enumeration.WorkflowRunCompleted, run.WorkflowRunStatus_Enum,
"The workflow completed sucessfully.");
}
}
//[Ignore("This test is the same as the failing intg workflow tests '610' and '620' due to the enforcement of cardinality. The problem is that the assignment of a relationship is not clearing the old relationship if the cardinality does not permit it.")]
public void ReassignReportDuringManagerCreate()
{
var aaManager = CodeNameResolver.GetTypeByName("AA_Manager").As <EntityType>();
var reportsTo = Entity.Get <Relationship>(new EntityRef("test:reportsTo"));
var oldMgr = new Entity(aaManager);
oldMgr.Save();
ToDelete.Add(oldMgr.Id);
var employee1 = CreateEmployee(oldMgr, reportsTo);
var employee2 = CreateEmployee(oldMgr, reportsTo);
var createActivity = new CreateActivity();
createActivity.InputArguments.Add(new ResourceArgument {
Name = "1"
}.Cast <ActivityArgument>());
createActivity.InputArguments.Add(new ResourceArgument {
Name = "1_value_"
}.Cast <ActivityArgument>());
createActivity.InputArguments.Add(new BoolArgument {
Name = "1_reverse"
}.Cast <ActivityArgument>());
createActivity.InputArguments.Add(new BoolArgument {
Name = "1_replace"
}.Cast <ActivityArgument>());
createActivity.Save();
ToDelete.Add(createActivity.Id);
var nextActivity = (CreateImplementation)createActivity.As <WfActivity>().CreateWindowsActivity();
var inputs = new Dictionary <string, object>
{
{
"Object", aaManager
},
{
"1_value_", new List <Entity>()
{
employee1, employee2
}
},
{
"1", reportsTo
},
{
"1_reverse", true
},
{
"1_replace", true
}
};
RunActivity(nextActivity, inputs);
}
public void TestResultTypeOfGroupByColumn()
{
var ireport = CodeNameResolver.GetInstance("rpt_CHART_EmployeeManager", "Report");
var report = ireport.As <Report>();
Assert.IsTrue(report.ReportColumns[0].ColumnExpression.ReportExpressionResultType.Is <ResourceArgument>());
Assert.AreEqual("AA_Manager", report.ReportColumns[0].ColumnExpression.ReportExpressionResultType.As <ResourceArgument>().ConformsToType.Name);
Assert.IsTrue(report.ReportColumns[1].ColumnExpression.ReportExpressionResultType.Is <IntegerArgument>());
}
public void A_ClearAll()
{
if (ReportId == 0)
{
ReportId = CodeNameResolver.GetInstance("Forms", "Report").Id;
}
TestHelpers.ClearServerCaches();
}
public void B_Clear_And_Warm()
{
if (ReportId == 0)
{
ReportId = CodeNameResolver.GetInstance("Forms", "Report").Id;
}
TestHelpers.ClearServerCaches();
BulkPreloader.TenantWarmup();
}
public void ReportPreloadTest( )
{
if (_reportId == 0)
{
_reportId = CodeNameResolver.GetInstance("Student report", "Report").Id;
}
var rq = new EntityRequest(_reportId, ReportHelpers.ReportPreloaderQuery, "ReportPreloadTest");
rq.IgnoreResultCache = true;
BulkPreloader.Preload(rq);
}
public void Convert_AllFields()
{
IEntity entity = CodeNameResolver.GetInstance("AF_All Fields", "Report");
var report = entity.As <EDC.ReadiNow.Model.Report>();
using (new SecurityBypassContext())
{
EventLog.Application.WriteTrace("Before convert report");
var sq = ReportToQueryConverter.Instance.Convert(report);
EventLog.Application.WriteTrace("After convert report");
}
}
public void GrcScriptCutdown_Warmup( )
{
reportId = CodeNameResolver.GetInstance("Business Units", "Report").Id;
formId = CodeNameResolver.GetInstance("Business Unit Form", "Custom Edit Form").Id;
typeId = CodeNameResolver.GetInstance("Business Unit", "Type").Id;
tabReportId = CodeNameResolver.GetInstance("Operational Impact List", "Report").Id;
tabRelId = CodeNameResolver.GetInstance("Business Function - Business Unit", "Relationship").Id;
tabEntityTypeId = CodeNameResolver.GetInstance("Business Function", "Type").Id;
listboxReportId = CodeNameResolver.GetInstance("Division Picker", "Report").Id;
pickerTypeId = CodeNameResolver.GetInstance("Employee", "Type").Id;
pickerReportId = CodeNameResolver.GetInstance("Employee Picker 2", "Report").Id;
}
public void Bug_25770_AssigningWithNull()
{
var aaManager = CodeNameResolver.GetTypeByName("AA_Manager").As <EntityType>();
var reportsTo = Entity.Get <Relationship>(new EntityRef("test:reportsTo"));
var createActivity = new CreateActivity();
createActivity.InputArguments.Add(new ResourceArgument {
Name = "1"
}.Cast <ActivityArgument>());
createActivity.InputArguments.Add(new ResourceArgument {
Name = "1_value_"
}.Cast <ActivityArgument>());
createActivity.InputArguments.Add(new BoolArgument {
Name = "1_reverse"
}.Cast <ActivityArgument>());
createActivity.InputArguments.Add(new BoolArgument {
Name = "1_replace"
}.Cast <ActivityArgument>());
createActivity.Save();
ToDelete.Add(createActivity.Id);
var nextActivity = (CreateImplementation)createActivity.As <WfActivity>().CreateWindowsActivity();
var inputs = new Dictionary <string, object>
{
{
"Object", aaManager
},
{
"1_value_", new List <Entity>()
{
null
} // NULL (This was a side effect of a problem in the expression engine)
},
{
"1", reportsTo
},
{
"1_reverse", true
},
{
"1_replace", true
}
};
RunActivity(nextActivity, inputs);
}
private string GetNewBusinessUnitJson( )
{
string fields = "";
string rels = "";
string entityRefs = "";
EntityType entityType = Entity.GetByName <EntityType>("Business Unit").Single( );
Action <long> addEntityRef = (id) =>
{
entityRefs += ",\n{'id':" + id + ",'ns':null,'alias':null}";
};
Action <string, string, string> setField = (field, type, value) =>
{
long fieldId = Factory.ScriptNameResolver.GetMemberOfType(field, entityType.Id, MemberType.Field).MemberId;
fields += ",\n{'fieldId':" + fieldId + ",'typeName':'" + type + "','value':'" + value + "'}";
addEntityRef(fieldId);
};
Action <string, string, string> setLookup = (relationship, type, value) =>
{
long relId = Factory.ScriptNameResolver.GetMemberOfType(relationship, entityType.Id, MemberType.Relationship).MemberId;
long entId = value == "%USER%" ? 99999999 : CodeNameResolver.GetInstance(value, type).Id;
rels += ",\n{'relTypeId':{'id':" + relId + ",'ns':null,'alias':null},'instances':[{'entity':" + entId + ",'relEntity':0,'dataState':'create'}],'removeExisting':true,'autoCardinality':true}";
addEntityRef(relId);
addEntityRef(entId);
};
long instanceId = 9007199254740986;
addEntityRef(entityType.Id);
addEntityRef(instanceId);
setField("Approval % Completed", "Decimal", "0");
setField("Name", "String", "%NAME%");
setField("Description", "Decimal", "TEST DESC");
setField("Function Completed", "Bool", "true");
setField("Approval Review Cycle", "Int32", "6");
setLookup("Approval status", "Authorisation Status", "In Draft");
setLookup("Owner", "Employee", "Peter Aylett");
setLookup("Approval review period", "Period WMY", "months");
setLookup("Owned by", "User Account", "%USER%");
string statement = @"{'ids':[" + instanceId + @"],
'entities':[{'id':" + instanceId + @",'typeIds':[" + entityType.Id + @"],
'fields':[" + fields.Substring(1) + @"],
'relationships':[" + rels.Substring(1) + @"],'dataState':'create'}],
'entityRefs':[" + entityRefs.Substring(1) + @"]}";
statement = statement.Replace("'", @"""");
return(statement);
}
//private ExpressionNode RunSingleTest(string script, BuilderSettings settings = null)
//{
// var result = ExpressionGrammar.ParseMacro(script);
// var root = CheckTerm(result.Root, Terms.Expression);
// StaticBuilder sb = new StaticBuilder();
// sb.Settings = settings ?? (new BuilderSettings());
// Expression tree = sb.CompileTree(root);
// return tree.Root;
//}
///// <summary>
///// Validate that the node represents the expected parse-term.
///// </summary>
//private ParseTreeNode CheckTerm(ParseTreeNode node, string expectedTerm)
//{
// Assert.AreEqual(expectedTerm, node.Term.Name);
// return node;
//}
private BuilderSettings CreateBuilderSettings(string contextDefinitionName)
{
var definition = CodeNameResolver.GetInstance(contextDefinitionName, EntityType.EntityType_Type).Single();
BuilderSettings settings = new BuilderSettings
{
RootContextType = new ExprType {
Type = DataType.Entity, EntityType = new EntityRef(definition.Id)
}
};
return(settings);
}
public void AddMissingAccessRules()
{
IAccessRuleFactory accessRuleFactory;
IAccessRuleReportFactory accessRuleReportFactory;
Subject administratorsRole;
Subject everyoneRole;
Solution coreDataSolution;
accessRuleReportFactory = new AccessRuleDisplayReportFactory();
accessRuleFactory = new AccessRuleFactory();
using (DatabaseContext databaseContext = DatabaseContext.GetContext(true))
using (new SecurityBypassContext())
{
administratorsRole = Entity.Get <Subject>("core:administratorRole", true);
everyoneRole = Entity.Get <Subject>("core:everyoneRole", true);
coreDataSolution = CodeNameResolver.GetInstance("ReadiNow Core Data", "Application").As <Solution>();
Console.WriteLine("Create access rule in solution {0}", coreDataSolution.Id);
CreateAccessRules(
accessRuleFactory,
accessRuleReportFactory,
administratorsRole,
new [] { "core:importConfig" },
new [] { Permissions.Create, Permissions.Read, Permissions.Modify, Permissions.Delete },
AdministratorsFullControlAccessRuleNameTemplate,
coreDataSolution);
CreateAccessRules(
accessRuleFactory,
accessRuleReportFactory,
administratorsRole,
new [] { "core:importRun" },
new [] { Permissions.Read, Permissions.Modify },
AdministratorsReadModifyAccessRuleNameTemplate,
coreDataSolution);
//var types = new[] { "core:board", "core:boardDimension" };
//DeleteAccessRules(types, EveryoneReadModifyControlAccessRuleNameTemplate);
//CreateAccessRules(
// accessRuleFactory,
// accessRuleReportFactory,
// everyoneRole,
// types,
// new[] { Permissions.Create, Permissions.Read, Permissions.Modify },
// EveryoneReadModifyControlAccessRuleNameTemplate,
// coreDataSolution);
databaseContext.CommitTransaction();
}
}
public void TestGetForm_ById( )
{
var employeeType = CodeNameResolver.GetTypeByName("AA_Employee").As <EntityType>( );
var employeeForm = employeeType.DefaultEditForm;
using (
var request = new PlatformHttpRequest(string.Format(@"data/v1/form/{0}", employeeForm.Id)))
{
HttpWebResponse response = request.GetResponse( );
// check that it worked (200)
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
}
}
Entity CreateEmployee(Entity oldMgr, Relationship reportsTo)
{
var aaEmployee = CodeNameResolver.GetTypeByName("AA_Employee").As <EntityType>();
var employee = new Entity(aaEmployee);
employee.Save();
var rel = employee.GetRelationships(reportsTo);
rel.Add(oldMgr);
employee.Save();
ToDelete.Add(employee.Id);
return(employee);
}
public void C_WithoutPreload()
{
if (ReportId == 0)
{
ReportId = CodeNameResolver.GetInstance("AF_All Fields", "Report").Id;
}
using (new SecurityBypassContext())
using (Profiler.Measure("C_WithoutPreload"))
{
var report = Entity.Get <Report>(ReportId);
var sq = ReportToQueryConverter.Instance.Convert(report);
}
}
public void UpdateField()
{
var employeeType = CodeNameResolver.GetTypeByName("AA_Person").As <EntityType>();
var ageField = employeeType.Fields.First(f => f.Name == "Age");
var bob = new Entity(employeeType);
bob.Save();
ToDelete.Add(bob.Id);
var updateActivity = new UpdateFieldActivity();
updateActivity.InputArguments.Add(new ResourceArgument {
Name = "1"
}.Cast <ActivityArgument>());
updateActivity.InputArguments.Add(new IntegerArgument {
Name = "1_value"
}.Cast <ActivityArgument>());
updateActivity.Save();
ToDelete.Add(updateActivity.Id);
var updateActionAs = updateActivity.As <WfActivity>();
ActivityImplementationBase nextActivity = updateActionAs.CreateWindowsActivity();
var args = new Dictionary <string, object>
{
{
"Record", bob
},
{
"1_value", 32
},
{
"1", (new EntityRef(ageField.Id)).Entity
}
};
RunActivity(nextActivity, args);
Entity.Get(bob);
var age = (int?)bob.GetField(ageField);
Assert.AreEqual(32, age);
}
public void TestANLSimpleChoiceCond()
{
var ireport = CodeNameResolver.GetInstance("ANL Simple Choice Cond", "Report");
var report = ireport.As <Report>();
// Check report
CheckResourceReport(report, "RPT_AllTypesChoice", 12);
var rootNode = report.RootNode.As <ResourceReportNode>();
var choiceNode = rootNode.RelatedReportNodes.Single().As <RelationshipReportNode>();
Assert.IsNotNull(choiceNode);
Assert.IsFalse(choiceNode.FollowInReverse == true);
// Check columns
var columns = report.ReportColumns.OrderBy(c => c.ColumnDisplayOrder).ToArray();
CheckIdColumn(columns[0], report.RootNode.Id);
CheckFieldColumn <StringArgument>(columns[1], "Text Field", "Text Field", report.RootNode);
CheckFieldColumn <StringArgument>(columns[2], "Multiline Text Field", "Multiline Text Field", report.RootNode);
CheckFieldColumn <IntegerArgument>(columns[3], "Number Field", "Number Field", report.RootNode);
CheckFieldColumn <IntegerArgument>(columns[4], "AutoNumber Field", "AutoNumber Field", report.RootNode);
CheckFieldColumn <DecimalArgument>(columns[5], "Decimal Field", "Decimal Field", report.RootNode);
CheckFieldColumn <CurrencyArgument>(columns[6], "Currency Field", "Currency Field", report.RootNode);
CheckFieldColumn <DateTimeArgument>(columns[7], "Date and Time Field", "Date and Time Field", report.RootNode);
CheckFieldColumn <DateArgument>(columns[8], "Date only Field", "Date only Field", report.RootNode);
CheckFieldColumn <TimeArgument>(columns[9], "Time only Field", "Time only Field", report.RootNode);
CheckFieldColumn <BoolArgument>(columns[10], "Yes/No Field", "Yes/No Field", report.RootNode);
CheckResourceExprColumn(columns[11], "Choice Field", choiceNode.As <ReportNode>(), "RPT_Choice");
// Check conditions
var conds = report.HasConditions.OrderBy(c => c.ConditionDisplayOrder).ToArray();
CheckCondition <ResourceListArgument>(conds[0], "Choice Field", "RPT_Choice");
CheckCondition <BoolArgument>(conds[1], "Yes/No Field");
CheckCondition <TimeArgument>(conds[2], "Time only Field");
CheckCondition <DateArgument>(conds[3], "Date only Field");
CheckCondition <DateTimeArgument>(conds[4], "Date and Time Field");
CheckCondition <CurrencyArgument>(conds[5], "Currency Field");
CheckCondition <DecimalArgument>(conds[6], "Decimal Field");
CheckCondition <IntegerArgument>(conds[7], "AutoNumber Field");
CheckCondition <StringArgument>(conds[8], "Multiline Text Field");
CheckCondition <IntegerArgument>(conds[9], "Number Field");
CheckCondition <StringArgument>(conds[10], "Text Field");
}
public string CreateQueryXml(string script, string rootType1)
{
EntityRef rootType;
if (rootType1.StartsWith("name:"))
{
rootType = new EntityRef(CodeNameResolver.GetTypeByName(rootType1.Substring(5)));
}
else
{
rootType = (EntityRef)rootType1; // cast alias string
}
StructuredQuery query = CreateQuery(script, rootType);
string xml = Serializer <StructuredQuery> .ToXml(query);
string xml2 = CleanXml(xml);
return(xml2);
}
public void TestReport_AA_Manager( )
{
long reportId = CodeNameResolver.GetInstance("AA_Manager", Report.Report_Type).Single().Id;
ReportSettings settings = new ReportSettings( );
settings.RequireFullMetadata = true;
settings.SupportPaging = true;
settings.PageSize = 200;
settings.RefreshCachedResult = true;
settings.RefreshCachedSql = true;
settings.RefreshCachedStructuredQuery = true;
var reportInterface = new ReportingInterface( );
ReportResult result = reportInterface.RunReport(reportId, settings);
Assert.That(result, Is.Not.Null);
Assert.That(result.GridData, Has.Count.GreaterThan(0));
}
public void Reverse_Relationship_IsCached( )
{
// columnRollup is a reverse relationship.
long reportId = CodeNameResolver.GetInstance("AA_Manager", Report.Report_Type).Single( ).Id;
string query = @"
isOfType.id,
reportColumns.isOfType.id,
reportColumns.columnRollup.isOfType.id";
var rq = new EntityRequest(reportId, query);
BulkPreloader.Preload(rq);
using (CacheManager.ExpectCacheHits( ))
{
var report = EDC.ReadiNow.Model.Entity.Get <EDC.ReadiNow.Model.Report>(reportId);
report.ReportColumns.Any(rc => rc.ColumnRollup.Any( ));
}
}
private Workflow CreateTestWf()
{
var person = CodeNameResolver.GetTypeByName("AA_Person").As <EntityType>();
var ageField = person.Fields.First(f => f.Name == "Age");
var wf = new Workflow
{
Name = "Test"
};
wf.AddDefaultExitPoint()
.AddInput <ResourceArgument>("ResourceId")
.AddUpdateField("Update Field", ageField.As <Resource>(), "ResourceId", "13");
wf.InputArgumentForAction = wf.InputArguments.First();
wf.Save();
ToDelete.Add(wf.Id);
return(wf);
}
public void TestGetForm_DoesNotReturnCalculations()
{
var calcTestType = CodeNameResolver.GetTypeByName("AA_Calculations").As <EntityType>();
var calcTestForm = calcTestType.DefaultEditForm;
using (
var request = new PlatformHttpRequest(string.Format(@"data/v1/form/{0}", calcTestForm.Id)))
{
HttpWebResponse response = request.GetResponse();
// check that it worked (200)
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
using (Stream stream = response.GetResponseStream())
using (TextReader reader = new StreamReader(stream))
{
string json = reader.ReadToEnd();
Assert.That(json, Contains.Substring("isCalculatedField"));
Assert.That(json, Is.Not.ContainsSubstring("fieldCalculation"));
}
}
}
public void RunReportWithCpuLimit(int limit, bool expectedSets)
{
IEntity entity = CodeNameResolver.GetInstance("AF_All Fields", "Report");
var report = entity.As <EDC.ReadiNow.Model.Report>();
var sq = ReportToQueryConverter.Instance.Convert(report);
// Run query
QuerySettings settings = new QuerySettings();
settings.CpuLimitSeconds = limit;
settings.RefreshCachedSql = true;
settings.RefreshCachedResult = true;
QueryResult result = Factory.QueryRunner.ExecuteQuery(sq, settings);
bool foundSet = result.Sql.Contains("set QUERY_GOVERNOR_COST_LIMIT 30");
bool foundUnset = result.Sql.Contains("set QUERY_GOVERNOR_COST_LIMIT 0");
Assert.That(foundSet, Is.EqualTo(expectedSets), "Found the setting of the limit");
Assert.That(foundUnset, Is.EqualTo(expectedSets), "found the unsetting of the limit");
}
public void TestGetInstance_NoDefaultForm( )
{
EntityType myDef = null;
try
{
var personType = CodeNameResolver.GetTypeByName("AA_Person").As <EntityType>( );
myDef = new EntityType( );
myDef.Inherits.Add(personType);
myDef.Save( );
IEntity myInst = Entity.Create(myDef.Id);
myInst.Save( );
using (
var request = new PlatformHttpRequest(string.Format(@"data/v1/instance/{0}", myInst.Id)))
{
HttpWebResponse response = request.GetResponse( );
// check that it worked (200)
Assert.IsTrue(response.StatusCode == HttpStatusCode.OK);
}
}
finally
{
try
{
if (myDef != null)
{
myDef.Delete( );
}
}
catch (Exception exc)
{
EventLog.Application.WriteError(exc.ToString( ));
}
}
}
