/// <summary>
/// Build one of the view models either for Details, Form, List.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="result"></param>
/// <param name="modelname"></param>
/// <param name="action"></param>
/// <returns></returns>
public static EntityBaseViewModel BuildViewModel <T>(EntityActionResult result, string modelname, string action, EntitySettingsHelper settings)
{
action = action.ToLower();
EntityBaseViewModel viewModel = null;
if (action == "details")
{
viewModel = BuildViewModelForDetails(result, modelname, action, settings);
}
else if (action == "edit" || action == "create")
{
viewModel = BuildViewModelForForm(result, modelname, action, settings);
}
else if (action == "deleted")
{
viewModel = BuildViewModelForDeleted(result, modelname, settings);
}
else // List/Index pages.
{
viewModel = BuildViewModelForIndex <T>(result, modelname, action, settings);
}
return(viewModel);
}
/// <summary>
/// Build general view model values.
/// </summary>
/// <param name="viewmodel"></param>
/// <param name="modelname"></param>
/// <param name="controlpath"></param>
/// <returns></returns>
public static void PopulateViewModel(EntityBaseViewModel viewmodel, string modelname, string controlpath, EntitySettingsHelper settings)
{
viewmodel.UrlCancel = "";
// This is "modellist", "modelform", "modeldetails" or whater is passed in.
viewmodel.ControlPath = controlpath;
// These two should be the same most of the time.
viewmodel.Name = modelname;
viewmodel.ControllerName = modelname;
viewmodel.UrlCreate = settings.GetOrDefault(modelname, "View.UrlForCreate", "/" + modelname + "/create");
viewmodel.UrlManage = settings.GetOrDefault(modelname, "View.UrlForManage", "/" + modelname + "/manage");
viewmodel.UrlIndex = settings.GetOrDefault(modelname, "View.UrlForIndex", "/" + modelname + "/index");
if (HttpContext.Current != null && HttpContext.Current.Request != null)
{
// Check the source url for supporting the back/cancel features.
if (HttpContext.Current.Request.UrlReferrer != null &&
!string.IsNullOrEmpty(HttpContext.Current.Request.UrlReferrer.PathAndQuery))
{
viewmodel.UrlCancel = HttpContext.Current.Request.UrlReferrer.PathAndQuery;
viewmodel.UrlBack = HttpContext.Current.Request.UrlReferrer.PathAndQuery;
}
}
}
/// <summary>
/// Converts the entity result to an actionresult.
/// </summary>
/// <param name="result">EntityActionResult</param>
/// <param name="successPage">Page url if result is succcessful.</param>
/// <param name="successAction"></param>
/// <param name="failPage"></param>
/// <param name="failAction"></param>
/// <returns></returns>
protected virtual ActionResult BuildActionResult(EntityActionResult result, string successPage = "", string successAction = "", string failPage = "", string failAction = "",
Action <EntityBaseViewModel> onAfterViewModelCreated = null, bool useDefaultFormAction = false)
{
// Not authorized or Not Available ?
var accessable = IsAccessable(result);
if (!accessable.Success)
{
return(View(accessable.Item));
}
PopulateErrors(result);
// No action provided? default to action of url /model/action.
if (string.IsNullOrEmpty(successAction))
{
if (string.IsNullOrEmpty(successPage))
{
successAction = "Manage";
}
else
{
successAction = successPage.Substring(successPage.LastIndexOf("/") + 1);
}
}
// Build the appropriate viewmodel based on success/failure of entity action( create/edit ) etc.
EntityBaseViewModel viewmodel = result.Success
? EntityViewHelper.BuildViewModel <T>(result, this._modelname, successAction, _settings)
: EntityViewHelper.BuildViewModel <T>(result, this._modelname, failAction, _settings);
// Option 1 : Default the form action to what ever it is currently ( typically used for create/edit pages for post backs ).
if (useDefaultFormAction && viewmodel is EntityFormViewModel)
{
var formModel = viewmodel as EntityFormViewModel;
var pathAndQuery = this.Request.Url.PathAndQuery;
var actionAndQuery = pathAndQuery.Substring(pathAndQuery.IndexOf("/", 1) + 1);
formModel.FormActionName = actionAndQuery;
formModel.RouteValues = null;
}
// Allow caller to do some additional processing.
if (onAfterViewModelCreated != null)
{
onAfterViewModelCreated(viewmodel);
}
string pageLocation = result.Success ? successPage : failPage;
return(View(pageLocation, viewmodel));
}
/// <summary>
/// Builds the view model.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="view">The view.</param>
/// <param name="entity">The entity.</param>
/// <param name="controlPath">The control path.</param>
/// <param name="useForm">if set to <c>true</c> [use form].</param>
/// <param name="conf">The conf.</param>
public static void BuildViewModel <T>(System.Web.Mvc.UrlHelper url, EntityBaseViewModel view, T entity, string controllerName, string controlPath, bool useForm, IDictionary conf) where T : IEntity
{
string baseurl = string.Empty;
var editUrl = url.Link("edit", controllerName, null);
var deleteUrl = url.Link("delete", controllerName, null);
var indexUrl = url.Link("index", controllerName, null);
var manageUrl = url.Link("manage", controllerName, null);
var copyUrl = url.Link("copy", controllerName, null);
bool allowEdit = false;
if (entity != null)
{
copyUrl += entity.Id;
editUrl += entity.Id;
deleteUrl += entity.Id;
allowEdit = Auth.IsUserOrAdmin(entity.CreateUser);
}
view.Name = controllerName;
view.ControllerName = controllerName;
view.UrlEdit = editUrl;
view.UrlCopy = copyUrl;
view.UrlDelete = deleteUrl;
view.UrlIndex = indexUrl;
view.UrlManage = manageUrl;
view.UrlCancel = manageUrl;
view.AllowDelete = allowEdit;
view.AllowDelete = allowEdit;
view.ControlPath = controlPath;
view.Config = conf;
if (view is EntityDetailsViewModel)
{
((EntityDetailsViewModel)view).Entity = entity;
}
else if (view is EntityFormViewModel)
{
((EntityFormViewModel)view).Entity = entity;
}
}
