protected virtual string GenerateOutputFileName(ActionArgs args, string outputFileName)
{
args.CommandArgument = args.CommandName;
args.CommandName = "FileName";
var values = new List <FieldValue>();
values.Add(new FieldValue("FileName", outputFileName));
args.Values = values.ToArray();
var result = ControllerFactory.CreateDataController().Execute(args.Controller, args.View, args);
foreach (var v in result.Values)
{
if (v.Name == "FileName")
{
outputFileName = Convert.ToString(v.Value);
break;
}
}
return(outputFileName);
}
protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
{
int pageSize = Int32.MaxValue;
if (arguments.MaximumRows > 0)
{
pageSize = arguments.MaximumRows;
}
int pageIndex = (arguments.StartRowIndex / pageSize);
PageRequest request = new PageRequest(pageIndex, pageSize, arguments.SortExpression, null);
request.RequiresMetaData = true;
request.RequiresRowCount = arguments.RetrieveTotalRowCount;
List <string> filter = new List <string>();
System.Collections.Specialized.IOrderedDictionary filterValues = FilterParameters.GetValues(HttpContext.Current, _owner);
foreach (Parameter p in FilterParameters)
{
if (filterValues[p.Name] != null)
{
string query = (p.Name + ":");
foreach (string s in Convert.ToString(filterValues[p.Name]).Split(',', ';'))
{
string q = Controller.ConvertSampleToQuery(s);
if (!(String.IsNullOrEmpty(q)))
{
query = (query + q);
}
}
filter.Add(query);
}
}
request.Filter = filter.ToArray();
ViewPage page = ControllerFactory.CreateDataController().GetPage(_dataController, _dataView, request);
if (arguments.RetrieveTotalRowCount)
{
arguments.TotalRowCount = page.TotalRowCount;
}
return(page.ToDataTable().DefaultView);
}
public void PopulateManyToManyField(string fieldName, string primaryKeyField, string targetController, string targetForeignKey1, string targetForeignKey2)
{
string filter = String.Format("{0}:={1}", targetForeignKey1, SelectFieldValue(primaryKeyField));
PageRequest request = new PageRequest(0, 300, null, new string[] {
filter
});
request.RequiresMetaData = true;
ViewPage page = ControllerFactory.CreateDataController().GetPage(targetController, null, request);
StringBuilder sb = new StringBuilder();
foreach (object[] row in page.Rows)
{
if (sb.Length > 0)
{
sb.Append(",");
}
sb.Append(page.SelectFieldValue(targetForeignKey2, row));
}
UpdateFieldValue(fieldName, sb.ToString());
}
public int SelectCount(
decimal?autoId,
string orderBy,
string deliveryDestination,
string customerMatCode,
string partsDevision,
string customerPO,
string key1,
string key2,
string key3,
string reliabilityDevision,
DateTime?deliveryDate,
string quantity,
string unit,
string plngPeriod,
string sAPCode,
string filename,
string statusCode,
string plantCode,
string addCode,
string arrivaltime,
string fromTo,
string deliveryDestinationCode,
string sort,
int maximumRows,
int startRowIndex,
string dataView)
{
PageRequest request = CreateRequest(autoId, orderBy, deliveryDestination, customerMatCode, partsDevision, customerPO, key1, key2, key3, reliabilityDevision, deliveryDate, quantity, unit, plngPeriod, sAPCode, filename, statusCode, plantCode, addCode, arrivaltime, fromTo, deliveryDestinationCode, sort, -1, startRowIndex);
request.RequiresMetaData = false;
request.MetadataFilter = new string[] {
"fields"
};
request.RequiresRowCount = true;
ViewPage page = ControllerFactory.CreateDataController().GetPage("THMOrderImport", dataView, request);
return(page.TotalRowCount);
}
public int SelectCount(
int?autoId,
string code,
string name,
string code2,
string code3,
string locationCode,
string plantCode,
string addressCode,
string contact,
string address,
string city,
string state,
string country,
string zIPCode,
string phone,
string mobile,
string fax,
string email,
string createBy,
DateTime?createDate,
string updateBy,
DateTime?updateDate,
string statusCode,
string sort,
int maximumRows,
int startRowIndex,
string dataView)
{
PageRequest request = CreateRequest(autoId, code, name, code2, code3, locationCode, plantCode, addressCode, contact, address, city, state, country, zIPCode, phone, mobile, fax, email, createBy, createDate, updateBy, updateDate, statusCode, sort, -1, startRowIndex);
request.RequiresMetaData = false;
request.RequiresRowCount = true;
ViewPage page = ControllerFactory.CreateDataController().GetPage("CustomerImport", dataView, request);
return(page.TotalRowCount);
}
public int SelectCount(
int?testExpressionID,
string testExpressionJoinCriteria,
string testExpressionLeftDataElementDataElementName,
string testExpressionLeftDataElementEventName,
string testExpressionRightDataElementDataElementName,
string testExpressionRightDataElementEventName,
string testExpressionOperatorCode,
string testExpressionTemplateTemplateName,
string testExpressionTestTestName,
string testExpressionAtrributeEventAttributeID,
string testExpressionLeftEventName,
string testExpressionLeftEventEventTypeEventType,
string testExpressionLeftEventLogSourceCode,
string testExpressionLeftEventTimeSourceCode,
string testExpressionRightEventName,
string testExpressionRightEventEventTypeEventType,
string testExpressionRightEventLogSourceCode,
string testExpressionRightEventTimeSourceCode,
int?testCriteriaID,
string testCriteriaCode,
bool?isPass,
DateTime?dateCreated,
DateTime?dateModified,
string sort,
int maximumRows,
int startRowIndex,
string dataView)
{
PageRequest request = CreateRequest(testExpressionID, testExpressionJoinCriteria, testExpressionLeftDataElementDataElementName, testExpressionLeftDataElementEventName, testExpressionRightDataElementDataElementName, testExpressionRightDataElementEventName, testExpressionOperatorCode, testExpressionTemplateTemplateName, testExpressionTestTestName, testExpressionAtrributeEventAttributeID, testExpressionLeftEventName, testExpressionLeftEventEventTypeEventType, testExpressionLeftEventLogSourceCode, testExpressionLeftEventTimeSourceCode, testExpressionRightEventName, testExpressionRightEventEventTypeEventType, testExpressionRightEventLogSourceCode, testExpressionRightEventTimeSourceCode, testCriteriaID, testCriteriaCode, isPass, dateCreated, dateModified, sort, -1, startRowIndex);
request.RequiresMetaData = false;
request.RequiresRowCount = true;
ViewPage page = ControllerFactory.CreateDataController().GetPage("CB_PassFailCriteria", dataView, request);
return(page.TotalRowCount);
}
private void ResolveLookups(ImportLookupDictionary lookups)
{
foreach (string fieldName in lookups.Keys)
{
DataField lookupField = lookups[fieldName];
if ((lookupField.Items.Count == 0) && (String.IsNullOrEmpty(lookupField.ItemsDataValueField) || String.IsNullOrEmpty(lookupField.ItemsDataTextField)))
{
PageRequest lookupRequest = new PageRequest();
lookupRequest.Controller = lookupField.ItemsDataController;
lookupRequest.View = lookupField.ItemsDataView;
lookupRequest.RequiresMetaData = true;
ViewPage lp = ControllerFactory.CreateDataController().GetPage(lookupRequest.Controller, lookupRequest.View, lookupRequest);
if (String.IsNullOrEmpty(lookupField.ItemsDataValueField))
{
foreach (DataField f in lp.Fields)
{
if (f.IsPrimaryKey)
{
lookupField.ItemsDataValueField = f.Name;
break;
}
}
}
if (String.IsNullOrEmpty(lookupField.ItemsDataTextField))
{
foreach (DataField f in lp.Fields)
{
if ((!(f.IsPrimaryKey) && !(f.Hidden)) && (!(f.AllowNulls) || (f.Type == "String")))
{
lookupField.ItemsDataTextField = f.Name;
break;
}
}
}
}
}
}
void IHttpHandler.ProcessRequest(HttpContext context)
{
string c = context.Request["c"];
string q = context.Request["q"];
PageRequest request = this.Request;
if ((request == null) && (String.IsNullOrEmpty(c) || String.IsNullOrEmpty(q)))
{
throw new Exception("Invalid report request.");
}
// create a data table for report
string templateName = null;
string aa = null;
string reportFormat = null;
if (request == null)
{
request = JsonConvert.DeserializeObject <PageRequest>(q);
templateName = context.Request.Form["a"];
aa = context.Request["aa"];
}
else
{
templateName = this.Arguments.TemplateName;
reportFormat = this.Arguments.Format;
request.FilterDetails = this.Arguments.FilterDetails;
}
request.PageIndex = 0;
request.PageSize = Int32.MaxValue;
request.RequiresMetaData = true;
// try to generate a report via a business rule
ActionArgs args = null;
if (!(String.IsNullOrEmpty(aa)))
{
args = JsonConvert.DeserializeObject <ActionArgs>(aa);
IDataController controller = ControllerFactory.CreateDataController();
ActionResult result = controller.Execute(args.Controller, args.View, args);
if (!(String.IsNullOrEmpty(result.NavigateUrl)))
{
AppendDownloadTokenCookie();
context.Response.Redirect(result.NavigateUrl);
}
if (result.Canceled)
{
AppendDownloadTokenCookie();
return;
}
result.RaiseExceptionIfErrors();
// parse action data
SortedDictionary <string, string> actionData = new SortedDictionary <string, string>();
((DataControllerBase)(controller)).Config.ParseActionData(args.Path, actionData);
List <string> filter = new List <string>();
foreach (string name in actionData.Keys)
{
string v = actionData[name];
if (name.StartsWith("_"))
{
if (name == "_controller")
{
request.Controller = v;
}
if (name == "_view")
{
request.View = v;
}
if (name == "_sortExpression")
{
request.SortExpression = v;
}
if (name == "_count")
{
request.PageSize = Convert.ToInt32(v);
}
if (name == "_template")
{
templateName = v;
}
}
else
if (v == "@Arguments_SelectedValues")
{
if ((args.SelectedValues != null) && (args.SelectedValues.Length > 0))
{
StringBuilder sb = new StringBuilder();
foreach (string key in args.SelectedValues)
{
if (sb.Length > 0)
{
sb.Append("$or$");
}
sb.Append(key);
}
filter.Add(String.Format("{0}:$in${1}", name, sb.ToString()));
}
else
{
return;
}
}
else
if (Regex.IsMatch(v, "^(\'|\").+(\'|\")$"))
{
filter.Add(String.Format("{0}:={1}", name, v.Substring(1, (v.Length - 2))));
}
else
if (args.Values != null)
{
foreach (FieldValue fv in args.Values)
{
if (fv.Name == v)
{
filter.Add(String.Format("{0}:={1}", name, fv.Value));
}
}
}
request.Filter = filter.ToArray();
}
}
// load report definition
string reportTemplate = Controller.CreateReportInstance(null, templateName, request.Controller, request.View);
ViewPage page = ControllerFactory.CreateDataController().GetPage(request.Controller, request.View, request);
DataTable table = page.ToDataTable();
// insert validation key
reportTemplate = _validationKeyRegex.Replace(reportTemplate, String.Format("/Blob.ashx?_validationKey={0}&", BlobAdapter.ValidationKey));
// figure report output format
if (this.Arguments == null)
{
Match m = Regex.Match(c, "^(ReportAs|Report)(Pdf|Excel|Image|Word|)$");
reportFormat = m.Groups[2].Value;
}
if (String.IsNullOrEmpty(reportFormat))
{
reportFormat = "Pdf";
}
// render a report
ReportData report = Render(request, table, reportTemplate, reportFormat);
if (this.Arguments != null)
{
this.Arguments.MimeType = report.MimeType;
this.Arguments.FileNameExtension = report.FileNameExtension;
this.Arguments.Encoding = report.Encoding;
this.OutputStream.Write(report.Data, 0, report.Data.Length);
}
else
{
// send report data to the client
context.Response.Clear();
context.Response.ContentType = report.MimeType;
context.Response.AddHeader("Content-Length", report.Data.Length.ToString());
AppendDownloadTokenCookie();
string fileName = FormatFileName(context, request, report.FileNameExtension);
if (String.IsNullOrEmpty(fileName))
{
fileName = String.Format("{0}_{1}.{2}", request.Controller, request.View, report.FileNameExtension);
if (args != null)
{
fileName = GenerateOutputFileName(args, fileName);
}
}
context.Response.AddHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
context.Response.OutputStream.Write(report.Data, 0, report.Data.Length);
}
}
public ActionResult Execute(string controller, string view, ActionArgs args)
{
return(ControllerFactory.CreateDataController().Execute(controller, view, args));
}
protected string PreparePrefetch(string content)
{
string output = null;
if (!(String.IsNullOrEmpty(Request.Url.Query)) || (Request.Headers["X-Cot-Manifest-Request"] == "true"))
{
return(output);
}
JToken token = ApplicationServices.TryGetJsonProperty(ApplicationServices.Current.DefaultSettings, "ui.history.dataView");
bool supportGridPrefetch = ((token == null) || !(Regex.IsMatch(((string)(token)), "\\b(search|sort|group|filter)\\b")));
List <string> prefetches = new List <string>();
bool prefetch = false;
List <Tuple <string, AttributeDictionary> > dataViews = new List <Tuple <string, AttributeDictionary> >();
foreach (Match m in Regex.Matches(content, "<div\\s+(id=\"(?\'Id\'\\w+)\")\\s+(?\'Props\'data-controller.*?)>"))
{
dataViews.Add(new Tuple <string, AttributeDictionary>(m.Groups["Id"].Value, new AttributeDictionary(m.Groups["Props"].Value)));
}
if (dataViews.Count == 1)
{
prefetch = true;
}
else
{
// LEGACY MASTER DETAIL PAGE SUPPORT
//
//
// 1. convert text of containers into single container with single dataview referring to virtual dashboard controller
//
// <div data-flow="row">
// <div id="view1" data-controller="Dashboards" data-view="form1" data-show-action-buttons="none"></div>
//
// </div>
//
// 2. produce response for this controller.
// a. standalone data views become data view fields of the virtual controller
// b. the layout of the page is optionally converted into form1 layout of the virtual controller
// c. render json response of virtual controller with layout in it
//
}
if (prefetch)
{
for (int i = 0; (i < dataViews.Count); i++)
{
Tuple <string, AttributeDictionary> dataView = dataViews[i];
string dataViewId = dataView.Item1;
AttributeDictionary attrs = dataView.Item2;
foreach (string p in UnsupportedDataViewProperties)
{
if (attrs.ContainsKey(p))
{
return(output);
}
}
string controllerName = attrs["data-controller"];
string viewId = null;
string tags = null;
attrs.TryGetValue("data-tags", out tags);
ControllerConfiguration c = Controller.CreateConfigurationInstance(GetType(), controllerName);
if (!(attrs.TryGetValue("data-view", out viewId)))
{
viewId = ((string)(c.Evaluate("string(/c:dataController/c:views/c:view[1]/@id)")));
}
XPathNavigator viewNav = c.SelectSingleNode("/c:dataController/c:views/c:view[@id=\'{0}\']", viewId);
if (!(Context.User.Identity.IsAuthenticated) && !((viewNav.GetAttribute("access", String.Empty) == "Public")))
{
return(output);
}
string roles = null;
if (attrs.TryGetValue("data-roles", out roles) && !(new ControllerUtilities().UserIsInRole(roles.Split(','))))
{
return(output);
}
tags = (tags
+ (" " + viewNav.GetAttribute("tags", String.Empty)));
bool isForm = (viewNav.GetAttribute("type", String.Empty) == "Form");
if (isForm)
{
_summaryDisabled = true;
}
if ((String.IsNullOrEmpty(tags) || !(Regex.IsMatch(tags, "\\bprefetch-data-none\\b"))) && (supportGridPrefetch || isForm))
{
PageRequest request = new PageRequest(-1, 30, null, null);
request.Controller = controllerName;
request.View = viewId;
request.Tag = tags;
request.ContextKey = dataViewId;
request.SupportsCaching = true;
if (attrs.ContainsKey("data-search-on-start"))
{
request.DoesNotRequireData = true;
}
ViewPage response = ControllerFactory.CreateDataController().GetPage(request.Controller, request.View, request);
string result = String.Format("{{ \"d\": {0} }}", ApplicationServices.CompressViewPageJsonOutput(JsonConvert.SerializeObject(response)));
prefetches.Add(String.Format("<script type=\"application/json\" id=\"_{0}_prefetch\">{1}</script>", dataViewId, Regex.Replace(result, "(<(/?\\s*script)(\\s|>))", "]_[$2$3]^[", RegexOptions.IgnoreCase)));
if (isForm)
{
foreach (DataField field in response.Fields)
{
if (String.IsNullOrEmpty(field.DataViewFilterSource) && (field.Type == "DataView"))
{
AttributeDictionary fieldAttr = new AttributeDictionary(String.Empty);
fieldAttr.Add("data-controller", field.DataViewController);
fieldAttr.Add("data-view", field.DataViewId);
fieldAttr.Add("data-tags", field.Tag);
if (field.DataViewSearchOnStart)
{
fieldAttr.Add("data-search-on-start", "true");
}
dataViews.Add(new Tuple <string, AttributeDictionary>(String.Format("{0}_{1}", dataViewId, field.Name), fieldAttr));
}
}
}
}
}
}
if (prefetches.Count > 0)
{
output = string.Join(String.Empty, prefetches);
}
return(output);
}
protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
{
var pageSize = Int32.MaxValue;
if (arguments.MaximumRows > 0)
{
pageSize = arguments.MaximumRows;
}
var pageIndex = (arguments.StartRowIndex / pageSize);
PageRequest request = null;
if (!(string.IsNullOrEmpty(_owner.PageRequestParameterName)))
{
var r = HttpContext.Current.Request.Params[_owner.PageRequestParameterName];
if (!(string.IsNullOrEmpty(r)))
{
request = JsonConvert.DeserializeObject <PageRequest>(r);
request.PageIndex = pageIndex;
request.PageSize = pageSize;
request.View = _owner.DataView;
}
}
if (request == null)
{
request = new PageRequest(pageIndex, pageSize, arguments.SortExpression, null);
var filter = new List <string>();
var filterValues = FilterParameters.GetValues(HttpContext.Current, _owner);
foreach (Parameter p in FilterParameters)
{
var v = filterValues[p.Name];
if (v != null)
{
var query = (p.Name + ":");
if ((p.DbType == DbType.Object) || (p.DbType == DbType.String))
{
foreach (var s in Convert.ToString(v).Split(',', ';'))
{
var q = Controller.ConvertSampleToQuery(s);
if (!(string.IsNullOrEmpty(q)))
{
query = (query + q);
}
}
}
else
{
query = string.Format("{0}={1}", query, v);
}
filter.Add(query);
}
}
request.Filter = filter.ToArray();
}
request.RequiresMetaData = true;
request.RequiresRowCount = arguments.RetrieveTotalRowCount;
var page = ControllerFactory.CreateDataController().GetPage(_dataController, _dataView, request);
if (arguments.RetrieveTotalRowCount)
{
arguments.TotalRowCount = page.TotalRowCount;
}
return(page.ToDataTable().DefaultView);
}
public virtual CommitResult Commit(JArray log)
{
_commitResult = new CommitResult();
try
{
if (log.Count > 0)
{
using (DataConnection connection = new DataConnection(LoadConfig(((string)(log[0]["controller"]))).ConnectionStringName, true))
{
int index = -1;
int sequence = -1;
int lastSequence = sequence;
string transactionScope = ((string)(ApplicationServices.Settings("odp.transactions.scope")));
for (int i = 0; (i < log.Count); i++)
{
JToken entry = log[i];
string controller = ((string)(entry["controller"]));
string view = ((string)(entry["view"]));
ActionArgs executeArgs = entry["args"].ToObject <ActionArgs>();
if (executeArgs.Sequence.HasValue)
{
sequence = executeArgs.Sequence.Value;
if ((transactionScope == "sequence") && (sequence != lastSequence && (i > 0)))
{
connection.Commit();
_commitResult.Sequence = lastSequence;
connection.BeginTransaction();
}
lastSequence = sequence;
}
ControllerConfiguration config = LoadConfig(executeArgs.Controller);
ProcessArguments(config, executeArgs);
ActionResult executeResult = ControllerFactory.CreateDataController().Execute(controller, view, executeArgs);
if (executeResult.Errors.Count > 0)
{
index = i;
_commitResult.Index = index;
_commitResult.Errors = executeResult.Errors.ToArray();
break;
}
else
{
ProcessResult(config, executeResult);
}
}
if (index == -1)
{
connection.Commit();
_commitResult.Sequence = sequence;
}
else
{
connection.Rollback();
_commitResult.Index = index;
}
}
}
}
catch (Exception ex)
{
_commitResult.Errors = new string[] {
ex.Message
};
_commitResult.Index = 0;
}
return(_commitResult);
}
protected override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)
{
int pageSize = Int32.MaxValue;
if (arguments.MaximumRows > 0)
{
pageSize = arguments.MaximumRows;
}
int pageIndex = (arguments.StartRowIndex / pageSize);
PageRequest request = null;
if (!(String.IsNullOrEmpty(_owner.PageRequestParameterName)))
{
string r = HttpContext.Current.Request.Params[_owner.PageRequestParameterName];
if (!(String.IsNullOrEmpty(r)))
{
#pragma warning disable 0618
System.Web.Script.Serialization.JavaScriptSerializer serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
#pragma warning restore 0618
request = serializer.Deserialize <PageRequest>(r);
request.PageIndex = pageIndex;
request.PageSize = pageSize;
request.View = _owner.DataView;
}
}
if (request == null)
{
request = new PageRequest(pageIndex, pageSize, arguments.SortExpression, null);
List <string> filter = new List <string>();
System.Collections.Specialized.IOrderedDictionary filterValues = FilterParameters.GetValues(HttpContext.Current, _owner);
foreach (Parameter p in FilterParameters)
{
object v = filterValues[p.Name];
if (v != null)
{
string query = (p.Name + ":");
if ((p.DbType == DbType.Object) || (p.DbType == DbType.String))
{
foreach (string s in Convert.ToString(v).Split(',', ';'))
{
string q = Controller.ConvertSampleToQuery(s);
if (!(String.IsNullOrEmpty(q)))
{
query = (query + q);
}
}
}
else
{
query = String.Format("{0}={1}", query, v);
}
filter.Add(query);
}
}
request.Filter = filter.ToArray();
}
request.RequiresMetaData = true;
request.RequiresRowCount = arguments.RetrieveTotalRowCount;
ViewPage page = ControllerFactory.CreateDataController().GetPage(_dataController, _dataView, request);
if (arguments.RetrieveTotalRowCount)
{
arguments.TotalRowCount = page.TotalRowCount;
}
return(page.ToDataTable().DefaultView);
}
private bool ProcessDownloadViaBusinessRule(Stream stream)
{
string contentTypeField = (ControllerFieldName + "ContentType");
string fileNameField = (ControllerFieldName + "FileName");
bool supportsContentType = false;
bool supportsFileName = false;
List <FieldValue> actionValues = CreateActionValues(stream, null, null, 0);
foreach (FieldValue v in actionValues)
{
if (v.Name.Equals(contentTypeField))
{
supportsContentType = true;
}
else
if (v.Name.Equals(fileNameField))
{
supportsFileName = true;
}
}
// try processing download via a business rule
ActionArgs args = new ActionArgs();
args.Controller = DataController;
args.CommandName = "DownloadFile";
args.CommandArgument = ControllerFieldName;
args.Values = actionValues.ToArray();
ActionResult r = ControllerFactory.CreateDataController().Execute(DataController, String.Empty, args);
foreach (FieldValue v in r.Values)
{
if (v.Name.Equals(contentTypeField))
{
Current.ContentType = Convert.ToString(v.Value);
}
else
if (v.Name.Equals(fileNameField))
{
Current.FileName = Convert.ToString(v.Value);
}
}
// see if we still need to retrieve the content type or the file name from the database
bool needsContentType = String.IsNullOrEmpty(Current.ContentType);
bool needsFileName = String.IsNullOrEmpty(Current.FileName);
if ((needsContentType && supportsContentType) || (needsFileName && supportsFileName))
{
actionValues = CreateActionValues(null, null, null, 0);
List <string> filter = new List <string>();
foreach (FieldValue v in actionValues)
{
filter.Add(String.Format("{0}:={1}", v.Name, v.Value));
}
PageRequest request = new PageRequest();
request.Controller = DataController;
request.View = "editForm1";
request.PageSize = 1;
request.RequiresMetaData = true;
request.Filter = filter.ToArray();
ViewPage page = ControllerFactory.CreateDataController().GetPage(request.Controller, request.View, request);
if (page.Rows.Count == 1)
{
object[] row = page.Rows[0];
if (supportsContentType)
{
Current.ContentType = Convert.ToString(page.SelectFieldValue(contentTypeField, row));
}
if (supportsFileName)
{
Current.FileName = Convert.ToString(page.SelectFieldValue(fileNameField, row));
}
}
}
return(r.Canceled);
}
protected virtual void ProcessArguments(ControllerConfiguration config, ActionArgs args)
{
if (args.Values == null)
{
return;
}
FieldValueDictionary values = new FieldValueDictionary(args);
_pk = null;
// detect negative primary keys
XPathNavigator pkNav = config.SelectSingleNode("/c:dataController/c:fields/c:field[@isPrimaryKey=\'true\']");
if (pkNav != null)
{
FieldValue fv = null;
if (values.TryGetValue(pkNav.GetAttribute("name", String.Empty), out fv))
{
int value = 0;
if ((fv.NewValue != null) && int.TryParse(Convert.ToString(fv.NewValue), out value))
{
if (value < 0)
{
if (args.CommandName == "Insert")
{
// request a new row from business rules
PageRequest newRowRequest = new PageRequest();
newRowRequest.Controller = args.Controller;
newRowRequest.View = args.View;
newRowRequest.Inserting = true;
newRowRequest.RequiresMetaData = true;
newRowRequest.MetadataFilter = new string[] {
"fields"
};
ViewPage page = ControllerFactory.CreateDataController().GetPage(newRowRequest.Controller, newRowRequest.View, newRowRequest);
if (page.NewRow != null)
{
for (int i = 0; (i < page.NewRow.Length); i++)
{
object newValue = page.NewRow[i];
if (newValue != null)
{
DataField field = page.Fields[i];
if (field.IsPrimaryKey)
{
// resolve the value of the primary key
ResolvePrimaryKey(args.Controller, fv.Name, value, newValue);
value = 0;
fv.NewValue = newValue;
}
else
{
// inject a missing default value in the arguments
FieldValue newFieldValue = null;
if (values.TryGetValue(field.Name, out newFieldValue))
{
if (!(newFieldValue.Modified))
{
newFieldValue.NewValue = newValue;
newFieldValue.Modified = true;
}
}
else
{
List <FieldValue> newValues = new List <FieldValue>(args.Values);
newFieldValue = new FieldValue(field.Name, newValue);
newValues.Add(newFieldValue);
args.Values = newValues.ToArray();
values[field.Name] = newFieldValue;
}
}
}
}
}
}
// resolve the primary key after the command execution
if (value < 0)
{
_pk = new FieldValue(fv.Name, value);
fv.NewValue = null;
fv.Modified = false;
}
}
}
}
}
// resolve negative foreign keys
if (_resolvedKeys.Count > 0)
{
XPathNodeIterator fkIterator = config.Select("/c:dataController/c:fields/c:field[c:items/@dataController]");
while (fkIterator.MoveNext())
{
FieldValue fv = null;
if (values.TryGetValue(fkIterator.Current.GetAttribute("name", String.Empty), out fv))
{
XPathNavigator itemsDataControllerNav = fkIterator.Current.SelectSingleNode("c:items/@dataController", config.Resolver);
object resolvedKey = null;
if (_resolvedKeys.TryGetValue(String.Format("{0}${1}", itemsDataControllerNav.Value, fv.NewValue), out resolvedKey))
{
fv.NewValue = resolvedKey;
}
}
}
}
}
public bool PopulateStaticItems(DataField field, FieldValue[] contextValues)
{
if (field.SupportsStaticItems() && (String.IsNullOrEmpty(field.ContextFields) || (contextValues != null)))
{
if (PopulatingStaticItems)
{
return(true);
}
PopulatingStaticItems = true;
try
{
string[] filter = null;
if (!(String.IsNullOrEmpty(field.ContextFields)))
{
List <string> contextFilter = new List <string>();
Match m = Regex.Match(field.ContextFields, "(\\w+)=(.+?)($|,)");
while (m.Success)
{
Match vm = Regex.Match(m.Groups[2].Value, "^\'(.+?)\'$");
if (vm.Success)
{
contextFilter.Add(String.Format("{0}:={1}", m.Groups[1].Value, vm.Groups[1].Value));
}
else
{
foreach (FieldValue cv in contextValues)
{
if (cv.Name == m.Groups[2].Value)
{
contextFilter.Add(String.Format("{0}:={1}", m.Groups[1].Value, cv.NewValue));
break;
}
}
}
m = m.NextMatch();
}
filter = contextFilter.ToArray();
}
PageRequest request = new PageRequest(-1, 1000, field.ItemsDataTextField, filter);
ViewPage page = ControllerFactory.CreateDataController().GetPage(field.ItemsDataController, field.ItemsDataView, request);
int dataValueFieldIndex = page.Fields.IndexOf(page.FindField(field.ItemsDataValueField));
if (dataValueFieldIndex == -1)
{
foreach (DataField aField in page.Fields)
{
if (aField.IsPrimaryKey)
{
dataValueFieldIndex = page.Fields.IndexOf(aField);
break;
}
}
}
int dataTextFieldIndex = page.Fields.IndexOf(page.FindField(field.ItemsDataTextField));
if (dataTextFieldIndex == -1)
{
int i = 0;
while ((dataTextFieldIndex == -1) && (i < page.Fields.Count))
{
DataField f = page.Fields[i];
if (!(f.Hidden) && (f.Type == "String"))
{
dataTextFieldIndex = i;
}
i++;
}
if (dataTextFieldIndex == -1)
{
dataTextFieldIndex = 0;
}
}
List <int> fieldIndexes = new List <int>();
fieldIndexes.Add(dataValueFieldIndex);
fieldIndexes.Add(dataTextFieldIndex);
if (!(String.IsNullOrEmpty(field.Copy)))
{
Match m = Regex.Match(field.Copy, "(\\w+)=(\\w+)");
while (m.Success)
{
int copyFieldIndex = page.Fields.IndexOf(page.FindField(m.Groups[2].Value));
if (copyFieldIndex >= 0)
{
fieldIndexes.Add(copyFieldIndex);
}
m = m.NextMatch();
}
}
foreach (object[] row in page.Rows)
{
object[] values = new object[fieldIndexes.Count];
for (int i = 0; (i < fieldIndexes.Count); i++)
{
int copyFieldIndex = fieldIndexes[i];
if (copyFieldIndex >= 0)
{
values[i] = row[copyFieldIndex];
}
}
field.Items.Add(values);
}
return(true);
}
finally
{
PopulatingStaticItems = false;
}
}
return(false);
}
public virtual void Process(string fileName, string controller, string view, string notify, List <string> userMapping)
{
BeforeProcess(fileName, controller, view, notify, userMapping);
string logFileName = Path.GetTempFileName();
StreamWriter log = File.CreateText(logFileName);
log.WriteLine("{0:s} Import process started.", DateTime.Now);
// retrieve metadata
PageRequest request = new PageRequest();
request.Controller = controller;
request.View = view;
request.RequiresMetaData = true;
ViewPage page = ControllerFactory.CreateDataController().GetPage(controller, view, request);
// open data reader and enumerate fields
OleDbDataReader reader = OpenRead(fileName, "*");
ImportMapDictionary map = new ImportMapDictionary();
ImportLookupDictionary lookups = new ImportLookupDictionary();
EnumerateFields(reader, page, map, lookups, userMapping);
// resolve lookup data value field and data text fields
ResolveLookups(lookups);
// insert records from the file
int recordCount = 0;
int errorCount = 0;
NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
Regex numberCleanupRegex = new Regex(String.Format("[^\\d\\{0}\\{1}\\{2}]", nfi.CurrencyDecimalSeparator, nfi.NegativeSign, nfi.NumberDecimalSeparator));
while (reader.Read())
{
ActionArgs args = new ActionArgs();
args.Controller = controller;
args.View = view;
args.LastCommandName = "New";
args.CommandName = "Insert";
List <FieldValue> values = new List <FieldValue>();
foreach (int index in map.Keys)
{
DataField field = map[index];
object v = reader[index];
if (DBNull.Value.Equals(v))
{
v = null;
}
else
if (field.Type != "String" && (v is string))
{
string s = ((string)(v));
if (field.Type == "Boolean")
{
v = s.ToLower();
}
else
if (!(field.Type.StartsWith("Date")) && field.Type != "Time")
{
v = numberCleanupRegex.Replace(s, String.Empty);
}
}
if (v != null)
{
DataField lookupField = null;
if (lookups.TryGetValue(field.Name, out lookupField))
{
if (lookupField.Items.Count > 0)
{
// copy static values
foreach (object[] item in lookupField.Items)
{
if (Convert.ToString(item[1]).Equals(Convert.ToString(v), StringComparison.CurrentCultureIgnoreCase))
{
values.Add(new FieldValue(lookupField.Name, item[0]));
}
}
}
else
{
PageRequest lookupRequest = new PageRequest();
lookupRequest.Controller = lookupField.ItemsDataController;
lookupRequest.View = lookupField.ItemsDataView;
lookupRequest.RequiresMetaData = true;
lookupRequest.PageSize = 1;
lookupRequest.Filter = new string[] {
String.Format("{0}:={1}{2}", lookupField.ItemsDataTextField, v, Convert.ToChar(0))
};
ViewPage vp = ControllerFactory.CreateDataController().GetPage(lookupRequest.Controller, lookupRequest.View, lookupRequest);
if (vp.Rows.Count > 0)
{
values.Add(new FieldValue(lookupField.ItemsDataValueField, vp.Rows[0][vp.Fields.IndexOf(vp.FindField(lookupField.ItemsDataValueField))]));
}
}
}
else
{
values.Add(new FieldValue(field.Name, v));
}
}
}
recordCount++;
if (values.Count > 0)
{
args.Values = values.ToArray();
ActionResult r = ControllerFactory.CreateDataController().Execute(controller, view, args);
if (r.Errors.Count > 0)
{
log.WriteLine("{0:s} Error importing record #{1}.", DateTime.Now, recordCount);
log.WriteLine();
foreach (string s in r.Errors)
{
log.WriteLine(s);
}
foreach (FieldValue v in values)
{
if (v.Modified)
{
log.WriteLine("{0}={1};", v.Name, v.Value);
}
}
log.WriteLine();
errorCount++;
}
}
else
{
log.WriteLine("{0:s} Record #1 has been ignored.", DateTime.Now, recordCount);
errorCount++;
}
}
reader.Close();
log.WriteLine("{0:s} Processed {1} records. Detected {2} errors.", DateTime.Now, recordCount, errorCount);
log.Close();
if (!(String.IsNullOrEmpty(notify)))
{
string[] recipients = notify.Split(',');
SmtpClient client = new SmtpClient();
foreach (string s in recipients)
{
string address = s.Trim();
if (!(String.IsNullOrEmpty(address)))
{
MailMessage message = new MailMessage();
try
{
message.To.Add(new MailAddress(address));
message.Subject = String.Format("Import of {0} has been completed", controller);
message.Body = File.ReadAllText(logFileName);
client.Send(message);
}
catch (Exception)
{
}
}
}
}
File.Delete(logFileName);
AfterProcess(fileName, controller, view, notify, userMapping);
}
public bool PopulateStaticItems(DataField field, FieldValue[] contextValues)
{
if ((!(String.IsNullOrEmpty(field.ItemsDataController)) && field.ItemsStyle != "Lookup") && (String.IsNullOrEmpty(field.ContextFields) || (contextValues != null)))
{
string[] filter = null;
if (!(String.IsNullOrEmpty(field.ContextFields)))
{
List <string> contextFilter = new List <string>();
Match m = Regex.Match(field.ContextFields, "(\\w+)=(.+?)($|,)", RegexOptions.Compiled);
while (m.Success)
{
Match vm = Regex.Match(m.Groups[2].Value, "^\'(.+?)\'$", RegexOptions.Compiled);
if (vm.Success)
{
contextFilter.Add(String.Format("{0}:={1}", m.Groups[1].Value, vm.Groups[1].Value));
}
else
{
foreach (FieldValue cv in contextValues)
{
if (cv.Name == m.Groups[2].Value)
{
contextFilter.Add(String.Format("{0}:={1}", m.Groups[1].Value, cv.NewValue));
break;
}
}
}
m = m.NextMatch();
}
filter = contextFilter.ToArray();
}
PageRequest request = new PageRequest(-1, 1000, field.ItemsDataTextField, filter);
ViewPage page = ControllerFactory.CreateDataController().GetPage(field.ItemsDataController, null, request);
int dataValueFieldIndex = page.Fields.IndexOf(page.FindField(field.ItemsDataValueField));
if (dataValueFieldIndex == -1)
{
foreach (DataField aField in page.Fields)
{
if (aField.IsPrimaryKey)
{
dataValueFieldIndex = page.Fields.IndexOf(aField);
break;
}
}
}
int dataTextFieldIndex = page.Fields.IndexOf(page.FindField(field.ItemsDataTextField));
if (dataTextFieldIndex == -1)
{
int i = 0;
while ((dataTextFieldIndex == -1) && (i < page.Fields.Count))
{
DataField f = page.Fields[i];
if (!(f.Hidden) && (f.Type == "String"))
{
dataTextFieldIndex = i;
}
i++;
}
if (dataTextFieldIndex == -1)
{
dataTextFieldIndex = 0;
}
}
List <int> fieldIndexes = new List <int>();
fieldIndexes.Add(dataValueFieldIndex);
fieldIndexes.Add(dataTextFieldIndex);
if (!(String.IsNullOrEmpty(field.Copy)))
{
Match m = Regex.Match(field.Copy, "(\\w+)=(\\w+)", RegexOptions.Compiled);
while (m.Success)
{
int copyFieldIndex = page.Fields.IndexOf(page.FindField(m.Groups[2].Value));
if (copyFieldIndex >= 0)
{
fieldIndexes.Add(copyFieldIndex);
}
m = m.NextMatch();
}
}
foreach (object[] row in page.Rows)
{
object[] values = new object[fieldIndexes.Count];
for (int i = 0; (i < fieldIndexes.Count); i++)
{
values[i] = row[fieldIndexes[i]];
}
field.Items.Add(values);
}
if (String.IsNullOrEmpty(field.ItemsDataTextField))
{
SortedDictionary <string, object[]> sortedList = new SortedDictionary <string, object[]>();
foreach (object[] item in field.Items)
{
string s = Convert.ToString(item[1]);
if (!(sortedList.ContainsKey(s)))
{
sortedList.Add(s, item);
}
}
field.Items.Clear();
foreach (object[] item in sortedList.Values)
{
field.Items.Add(item);
}
}
return(true);
}
return(false);
}
public object[] GetListOfValues(string controller, string view, DistinctValueRequest request)
{
return(ControllerFactory.CreateDataController().GetListOfValues(controller, view, request));
}
public ViewPage[] GetPageList(PageRequest[] requests)
{
return(((DataControllerBase)(ControllerFactory.CreateDataController())).GetPageList(requests));
}
public ActionResult[] ExecuteList(ActionArgs[] requests)
{
return(((DataControllerBase)(ControllerFactory.CreateDataController())).ExecuteList(requests));
}
public ViewPage GetPage(string controller, string view, PageRequest request)
{
return(ControllerFactory.CreateDataController().GetPage(controller, view, request));
}
void IHttpHandler.ProcessRequest(HttpContext context)
{
string fileName = null;
string q = context.Request.Params["q"];
if (!(String.IsNullOrEmpty(q)))
{
if (q.Contains("{"))
{
q = Convert.ToBase64String(Encoding.Default.GetBytes(q));
context.Response.Redirect(((context.Request.AppRelativeCurrentExecutionFilePath + "?q=")
+ HttpUtility.UrlEncode(q)));
}
q = Encoding.Default.GetString(Convert.FromBase64String(q));
//
#pragma warning disable 0618
System.Web.Script.Serialization.JavaScriptSerializer serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
//
#pragma warning restore 0618
ActionArgs args = serializer.Deserialize <ActionArgs>(q);
// execute data export
IDataController controller = ControllerFactory.CreateDataController();
// create an Excel Web Query
if ((args.CommandName == "ExportRowset") && !(context.Request.Url.AbsoluteUri.Contains("&d")))
{
string webQueryUrl = (context.Request.Url.AbsoluteUri + "&d");
context.Response.Write(("Web\r\n1\r\n" + webQueryUrl));
context.Response.ContentType = "text/x-ms-iqy";
context.Response.AddHeader("Content-Disposition", String.Format(String.Format("attachment; filename={0}", GenerateOutputFileName(args, String.Format("{0}_{1}.iqy", args.Controller, args.View)))));
return;
}
// export data in the requested format
ActionResult result = controller.Execute(args.Controller, args.View, args);
fileName = ((string)(result.Values[0].Value));
// send file to output
if (File.Exists(fileName))
{
if (args.CommandName == "ExportCsv")
{
context.Response.ContentType = "text/csv";
context.Response.AddHeader("Content-Disposition", String.Format(String.Format("attachment; filename={0}", GenerateOutputFileName(args, String.Format("{0}_{1}.csv", args.Controller, args.View)))));
context.Response.Charset = "utf-8";
context.Response.Write(Convert.ToChar(65279));
}
else
if (args.CommandName == "ExportRowset")
{
context.Response.ContentType = "text/xml";
}
else
{
context.Response.ContentType = "application/rss+xml";
}
StreamReader reader = File.OpenText(fileName);
while (!(reader.EndOfStream))
{
string s = reader.ReadLine();
context.Response.Output.WriteLine(s);
}
reader.Close();
File.Delete(fileName);
}
}
if (String.IsNullOrEmpty(fileName))
{
throw new HttpException(404, String.Empty);
}
}
protected virtual void ProcessArguments(ControllerConfiguration config, ActionArgs args)
{
if (args.Values == null)
{
return;
}
var values = new FieldValueDictionary(args);
_pk = null;
// detect negative primary keys
var pkNav = config.SelectSingleNode("/c:dataController/c:fields/c:field[@isPrimaryKey=\'true\']");
if (pkNav != null)
{
FieldValue fvo = null;
if (values.TryGetValue(pkNav.GetAttribute("name", string.Empty), out fvo))
{
var value = 0;
if ((fvo.Value != null) && int.TryParse(Convert.ToString(fvo.Value), out value))
{
if (value < 0)
{
if (args.CommandName == "Insert")
{
// request a new row from business rules
var newRowRequest = new PageRequest();
newRowRequest.Controller = args.Controller;
newRowRequest.View = args.View;
newRowRequest.Inserting = true;
newRowRequest.RequiresMetaData = true;
newRowRequest.MetadataFilter = new string[] {
"fields"
};
var page = ControllerFactory.CreateDataController().GetPage(newRowRequest.Controller, newRowRequest.View, newRowRequest);
if (page.NewRow != null)
{
for (var i = 0; (i < page.NewRow.Length); i++)
{
var newValue = page.NewRow[i];
if (newValue != null)
{
var field = page.Fields[i];
if (field.IsPrimaryKey)
{
// resolve the value of the primary key
ResolvePrimaryKey(args.Controller, fvo.Name, value, newValue);
value = 0;
fvo.NewValue = newValue;
}
else
{
// inject a missing default value in the arguments
FieldValue newFieldValue = null;
if (values.TryGetValue(field.Name, out newFieldValue))
{
if (!newFieldValue.Modified)
{
newFieldValue.NewValue = newValue;
newFieldValue.Modified = true;
}
}
else
{
var newValues = new List <FieldValue>(args.Values);
newFieldValue = new FieldValue(field.Name, newValue);
newValues.Add(newFieldValue);
args.Values = newValues.ToArray();
values[field.Name] = newFieldValue;
}
}
}
}
}
}
// resolve the primary key after the command execution
if (value < 0)
{
if (args.CommandName == "Insert")
{
if (pkNav.SelectSingleNode("c:items/@dataController", config.Resolver) == null)
{
_pk = new FieldValue(fvo.Name, value);
fvo.NewValue = null;
fvo.Modified = false;
}
}
else
{
// otherwise try to resolve the primary key
object resolvedKey = null;
if (_resolvedKeys.TryGetValue(string.Format("{0}${1}", args.Controller, fvo.Value), out resolvedKey))
{
if (fvo.Modified)
{
fvo.NewValue = resolvedKey;
}
else
{
fvo.OldValue = resolvedKey;
}
}
}
}
}
}
}
}
// resolve negative foreign keys
if (_resolvedKeys.Count > 0)
{
var fkIterator = config.Select("/c:dataController/c:fields/c:field[c:items/@dataController]");
while (fkIterator.MoveNext())
{
FieldValue fvo = null;
if (values.TryGetValue(fkIterator.Current.GetAttribute("name", string.Empty), out fvo))
{
var itemsDataControllerNav = fkIterator.Current.SelectSingleNode("c:items/@dataController", config.Resolver);
object resolvedKey = null;
if (_resolvedKeys.TryGetValue(string.Format("{0}${1}", itemsDataControllerNav.Value, fvo.Value), out resolvedKey))
{
if (fvo.Modified)
{
fvo.NewValue = resolvedKey;
}
else
{
fvo.OldValue = resolvedKey;
}
}
}
}
}
// scan resolved primary keys and look for the one that are matching the keys referenced in SelectedValues, ExternalFilter, or Filter of the action
foreach (var resolvedKeyInfo in _resolvedKeys.Keys)
{
var separatorIndex = resolvedKeyInfo.IndexOf("$");
var resolvedController = resolvedKeyInfo.Substring(0, separatorIndex);
var unresolvedKeyValue = resolvedKeyInfo.Substring((separatorIndex + 1));
object resolvedKeyValue = null;
if ((args.Controller == resolvedController) && _resolvedKeys.TryGetValue(resolvedKeyInfo, out resolvedKeyValue))
{
var resolvedKeyValueAsString = resolvedKeyValue.ToString();
// resolve primary key references in SelectedValues
if (args.SelectedValues != null)
{
for (var selectedValueIndex = 0; (selectedValueIndex < args.SelectedValues.Length); selectedValueIndex++)
{
var selectedKey = Regex.Split(args.SelectedValues[selectedValueIndex], ",");
for (var keyValueIndex = 0; (keyValueIndex < selectedKey.Length); keyValueIndex++)
{
if (selectedKey[keyValueIndex] == unresolvedKeyValue)
{
selectedKey[keyValueIndex] = resolvedKeyValueAsString;
args.SelectedValues[selectedValueIndex] = string.Join(",", selectedKey);
selectedKey = null;
break;
}
}
if (selectedKey == null)
{
break;
}
}
}
}
}
}
void IHttpHandler.ProcessRequest(HttpContext context)
{
string c = context.Request["c"];
string q = context.Request["q"];
PageRequest request = this.Request;
if ((request == null) && (String.IsNullOrEmpty(c) || String.IsNullOrEmpty(q)))
{
throw new Exception("Invalid report request.");
}
//
#pragma warning disable 0618
System.Web.Script.Serialization.JavaScriptSerializer serializer = new System.Web.Script.Serialization.JavaScriptSerializer();
//
#pragma warning restore 0618
// create a data table for report
string templateName = null;
string aa = null;
string reportFormat = null;
if (request == null)
{
request = serializer.Deserialize <PageRequest>(q);
templateName = context.Request.Form["a"];
aa = context.Request["aa"];
}
else
{
templateName = this.Arguments.TemplateName;
reportFormat = this.Arguments.Format;
request.FilterDetails = this.Arguments.FilterDetails;
}
request.PageIndex = 0;
request.PageSize = Int32.MaxValue;
request.RequiresMetaData = true;
// try to generate a report via a business rule
ActionArgs args = null;
if (!(String.IsNullOrEmpty(aa)))
{
args = serializer.Deserialize <ActionArgs>(aa);
IDataController controller = ControllerFactory.CreateDataController();
ActionResult result = controller.Execute(args.Controller, args.View, args);
if (!(String.IsNullOrEmpty(result.NavigateUrl)))
{
AppendDownloadTokenCookie();
context.Response.Redirect(result.NavigateUrl);
}
if (result.Canceled)
{
AppendDownloadTokenCookie();
return;
}
result.RaiseExceptionIfErrors();
// parse action data
SortedDictionary <string, string> actionData = new SortedDictionary <string, string>();
((DataControllerBase)(controller)).Config.ParseActionData(args.Path, actionData);
List <string> filter = new List <string>();
foreach (string name in actionData.Keys)
{
string v = actionData[name];
if (name.StartsWith("_"))
{
if (name == "_controller")
{
request.Controller = v;
}
if (name == "_view")
{
request.View = v;
}
if (name == "_sortExpression")
{
request.SortExpression = v;
}
if (name == "_count")
{
request.PageSize = Convert.ToInt32(v);
}
if (name == "_template")
{
templateName = v;
}
}
else
if (v == "@Arguments_SelectedValues")
{
if ((args.SelectedValues != null) && (args.SelectedValues.Length > 0))
{
StringBuilder sb = new StringBuilder();
foreach (string key in args.SelectedValues)
{
if (sb.Length > 0)
{
sb.Append("$or$");
}
sb.Append(key);
}
filter.Add(String.Format("{0}:$in${1}", name, sb.ToString()));
}
else
{
return;
}
}
else
if (Regex.IsMatch(v, "^(\'|\").+(\'|\")$"))
{
filter.Add(String.Format("{0}:={1}", name, v.Substring(1, (v.Length - 2))));
}
else
if (args.Values != null)
{
foreach (FieldValue fv in args.Values)
{
if (fv.Name == v)
{
filter.Add(String.Format("{0}:={1}", name, fv.Value));
}
}
}
request.Filter = filter.ToArray();
}
}
// load report definition
string reportTemplate = Controller.CreateReportInstance(null, templateName, request.Controller, request.View);
ViewPage page = ControllerFactory.CreateDataController().GetPage(request.Controller, request.View, request);
DataTable table = page.ToDataTable();
// insert validation key
reportTemplate = _validationKeyRegex.Replace(reportTemplate, String.Format("/Blob.ashx?_validationKey={0}&", BlobAdapter.ValidationKey));
// figure report output format
if (this.Arguments == null)
{
Match m = Regex.Match(c, "^(ReportAs|Report)(Pdf|Excel|Image|Word|)$");
reportFormat = m.Groups[2].Value;
}
if (String.IsNullOrEmpty(reportFormat))
{
reportFormat = "Pdf";
}
// render a report
string mimeType = null;
string encoding = null;
string fileNameExtension = null;
string[] streams = null;
Warning[] warnings = null;
using (LocalReport report = new LocalReport())
{
report.EnableHyperlinks = true;
report.EnableExternalImages = true;
report.LoadReportDefinition(new StringReader(reportTemplate));
report.DataSources.Add(new ReportDataSource(request.Controller, table));
report.EnableExternalImages = true;
foreach (ReportParameterInfo p in report.GetParameters())
{
if (p.Name.Equals("FilterDetails") && !(String.IsNullOrEmpty(request.FilterDetails)))
{
report.SetParameters(new ReportParameter("FilterDetails", request.FilterDetails));
}
if (p.Name.Equals("BaseUrl"))
{
string baseUrl = String.Format("{0}://{1}{2}", context.Request.Url.Scheme, context.Request.Url.Authority, context.Request.ApplicationPath.TrimEnd('/'));
report.SetParameters(new ReportParameter("BaseUrl", baseUrl));
}
if (p.Name.Equals("Query") && !(String.IsNullOrEmpty(q)))
{
report.SetParameters(new ReportParameter("Query", HttpUtility.UrlEncode(q)));
}
}
report.SetBasePermissionsForSandboxAppDomain(new System.Security.PermissionSet(System.Security.Permissions.PermissionState.Unrestricted));
byte[] reportData = report.Render(reportFormat, null, out mimeType, out encoding, out fileNameExtension, out streams, out warnings);
if (this.Arguments != null)
{
this.Arguments.MimeType = mimeType;
this.Arguments.FileNameExtension = fileNameExtension;
this.Arguments.Encoding = encoding;
this.OutputStream.Write(reportData, 0, reportData.Length);
}
else
{
// send report data to the client
context.Response.Clear();
context.Response.ContentType = mimeType;
context.Response.AddHeader("Content-Length", reportData.Length.ToString());
AppendDownloadTokenCookie();
string fileName = FormatFileName(context, request, fileNameExtension);
if (String.IsNullOrEmpty(fileName))
{
fileName = String.Format("{0}_{1}.{2}", request.Controller, request.View, fileNameExtension);
if (args != null)
{
fileName = GenerateOutputFileName(args, fileName);
}
}
context.Response.AddHeader("Content-Disposition", String.Format("attachment;filename={0}", fileName));
context.Response.OutputStream.Write(reportData, 0, reportData.Length);
}
}
}
public virtual CommitResult Commit(JArray log)
{
_commitResult = new CommitResult();
try
{
if (log.Count > 0)
{
using (var tx = new DataTransaction(LoadConfig(((string)(log[0]["controller"]))).ConnectionStringName))
{
var index = -1;
var sequence = -1;
var lastSequence = sequence;
var commitedValueCount = _commitResult.Values.Count;
var transactionScope = ((string)(ApplicationServices.Settings("odp.transactions.scope")));
for (var i = 0; (i < log.Count); i++)
{
var entry = log[i];
var controller = ((string)(entry["controller"]));
var view = ((string)(entry["view"]));
ActionArgs.Forget();
var executeArgs = entry["args"].ToObject <ActionArgs>();
if (executeArgs.Sequence.HasValue)
{
sequence = executeArgs.Sequence.Value;
if (transactionScope != "all" && (sequence != lastSequence && (i > 0)))
{
tx.Commit();
_commitResult.Sequence = lastSequence;
commitedValueCount = _commitResult.Values.Count;
tx.BeginTransaction();
}
lastSequence = sequence;
}
var config = LoadConfig(executeArgs.Controller);
ProcessArguments(config, executeArgs);
var executeResult = ControllerFactory.CreateDataController().Execute(controller, view, executeArgs);
if (executeResult.Errors.Count > 0)
{
index = i;
_commitResult.Index = index;
_commitResult.Errors = executeResult.Errors.ToArray();
break;
}
else
{
ProcessResult(config, executeResult);
}
}
if (index == -1)
{
tx.Commit();
_commitResult.Sequence = sequence;
commitedValueCount = _commitResult.Values.Count;
}
else
{
tx.Rollback();
_commitResult.Index = index;
_commitResult.Values.RemoveRange(commitedValueCount, (_commitResult.Values.Count - commitedValueCount));
}
}
}
}
catch (Exception ex)
{
_commitResult.Errors = new string[] {
ex.Message
};
_commitResult.Index = 0;
}
return(_commitResult);
}
