public virtual ActionResult EditObject(ObjectAndControlData controlData, FormCollection form) {
            Decrypt(form);
            controlData.Form = form;
            var nakedObject = controlData.GetNakedObject(Facade);
            SetExistingCollectionFormats(form);

            if (nakedObject.IsNotPersistent) {
                RefreshTransient(nakedObject, form);
            }

            switch (controlData.SubAction) {
                case (ObjectAndControlData.SubActionType.Action):
                    SetNewCollectionFormats(controlData);
                    return ActionOnNotPersistentObject(controlData);
                case (ObjectAndControlData.SubActionType.None):
                    AddAttemptedValuesNew(nakedObject, controlData);
                    return View("ObjectEdit", nakedObject.GetDomainObject());
                case (ObjectAndControlData.SubActionType.Pager):
                    SetNewCollectionFormats(controlData);
                    return AppropriateView(controlData, nakedObject);
                case (ObjectAndControlData.SubActionType.Redisplay):
                    return Redisplay(controlData);
            }
            Log.ErrorFormat("SubAction handling not implemented in EditObject for {0}", controlData.SubAction.ToString());
            throw new NotImplementedException(controlData.SubAction.ToString());
        }
예제 #2
0
 public virtual ActionResult Details(ObjectAndControlData controlData) {
     Assert.AssertTrue(controlData.SubAction == ObjectAndControlData.SubActionType.Details ||
                       controlData.SubAction == ObjectAndControlData.SubActionType.None);
     INakedObject nakedObject = FilterCollection(controlData.GetNakedObject(), controlData);
     SetNewCollectionFormats(controlData);
     return AppropriateView(controlData, nakedObject);
 }
 public virtual ActionResult ClearHistoryOthers(string id, ObjectAndControlData controlData) {
     var nakedObject = GetNakedObjectFromId(id);
     Session.RemoveOthersFromCache(Facade, nakedObject.GetDomainObject(), ObjectCache.ObjectFlag.BreadCrumb);
     SetNewCollectionFormats(controlData);
     SetControllerName(nakedObject.GetDomainObject());
     return AppropriateView(controlData, nakedObject);
 }
        public virtual ActionResult Details(ObjectAndControlData controlData) {
            Debug.Assert(controlData.SubAction == ObjectAndControlData.SubActionType.Details ||
                         controlData.SubAction == ObjectAndControlData.SubActionType.None);

            var nakedObject = controlData.GetNakedObject(Facade);
            nakedObject = FilterCollection(nakedObject, controlData);
            SetNewCollectionFormats(controlData);
            return AppropriateView(controlData, nakedObject);
        }
        public virtual ActionResult Cancel(string nextId, ObjectAndControlData controlData) {
            var nextNakedObject = string.IsNullOrEmpty(nextId) ? null : GetNakedObjectFromId(nextId);

            if (nextNakedObject == null) {
                return RedirectToAction(IdConstants.IndexAction, IdConstants.HomeName);
            }

            SetNewCollectionFormats(controlData);
            SetControllerName(nextNakedObject.GetDomainObject());
            return AppropriateView(controlData, nextNakedObject);
        }
예제 #6
0
        internal ActionResult AppropriateView(ObjectAndControlData controlData, INakedObject nakedObject, INakedObjectAction action = null, string propertyName = null) {
            if (nakedObject == null) {
                // no object to go to 
                // if action on object go to that object. 
                // if action on collection go to collection 
                // if action on service go to last object 

                nakedObject = controlData.GetNakedObject();

                if (nakedObject.Specification.IsService) {
                    object lastObject = Session.LastObject(ObjectCache.ObjectFlag.BreadCrumb);
                    if (lastObject == null) {
                        TempData[IdHelper.NofMessages] = NakedObjectsContext.MessageBroker.Messages;
                        TempData[IdHelper.NofWarnings] = NakedObjectsContext.MessageBroker.Warnings;
                        return RedirectToAction(IdHelper.IndexAction, IdHelper.HomeName);
                    }

                    nakedObject = FrameworkHelper.GetNakedObject(lastObject);
                }
            }

            if (nakedObject.Specification.IsCollection && !nakedObject.Specification.IsParseable) {
                var collection = nakedObject.GetAsQueryable();
                int collectionSize = collection.Count();
                if (collectionSize == 1) {
                    // remove any paging data - to catch case where custom page has embedded standalone collection as paging data will confuse rendering 
                    ViewData.Remove(IdHelper.PagingData);
                    return View("ObjectView", collection.First());
                }

                nakedObject = Page(nakedObject, collectionSize, controlData, nakedObject.IsNotQueryable());
                action = action ?? ((CollectionMemento)nakedObject.Oid).Action;
                int page, pageSize;
                CurrentlyPaging(controlData, collectionSize, out page, out pageSize);
                var format = ViewData["NofCollectionFormat"] as string;
                return View("StandaloneTable", ActionResultModel.Create(action, nakedObject, page, pageSize, format));
            }
            // remove any paging data - to catch case where custom page has embedded standalone collection as paging data will confuse rendering   
            ViewData.Remove(IdHelper.PagingData);

            if (controlData.DataDict.Values.Contains("max")) {
                // maximizing an inline object - do not update history
                ViewData.Add("updateHistory", false);
            }

            return propertyName == null ? View(nakedObject.IsNotPersistent() ? "ObjectView" : "ViewNameSetAfterTransaction", nakedObject.Object) :
                                          View(nakedObject.IsNotPersistent() ? "PropertyView" : "ViewNameSetAfterTransaction", new PropertyViewModel(nakedObject.Object, propertyName));
        }
        public virtual ActionResult Details(ObjectAndControlData controlData, FormCollection form) {
            Decrypt(form);
            controlData.Form = form;
            Debug.Assert(controlData.SubAction == ObjectAndControlData.SubActionType.Redisplay ||
                         controlData.SubAction == ObjectAndControlData.SubActionType.Details ||
                         controlData.SubAction == ObjectAndControlData.SubActionType.Cancel ||
                         controlData.SubAction == ObjectAndControlData.SubActionType.None);
            var nakedObject = FilterCollection(controlData.GetNakedObject(Facade), controlData);
            SetExistingCollectionFormats(form);
            SetNewCollectionFormats(controlData);

            nakedObject.SetIsNotQueryableState(true);

            if (controlData.SubAction == ObjectAndControlData.SubActionType.Cancel && nakedObject.IsTransient && nakedObject.IsUserPersistable) {
                // remove from cache and return to last object 
                Session.RemoveFromCache(Facade, nakedObject, ObjectCache.ObjectFlag.BreadCrumb);
                return AppropriateView(controlData, null);
            }
            string property = DisplaySingleProperty(controlData, controlData.DataDict);
            return AppropriateView(controlData, nakedObject, null, property);
        }
예제 #8
0
        public virtual ActionResult Details(ObjectAndControlData controlData, FormCollection form) {
            Decrypt(form);
            controlData.Form = form;
            Assert.AssertTrue(controlData.SubAction == ObjectAndControlData.SubActionType.Redisplay ||
                              controlData.SubAction == ObjectAndControlData.SubActionType.Details ||
                              controlData.SubAction == ObjectAndControlData.SubActionType.Cancel ||
                              controlData.SubAction == ObjectAndControlData.SubActionType.None);
            INakedObject nakedObject = FilterCollection(controlData.GetNakedObject(), controlData);
            SetExistingCollectionFormats(nakedObject, form);
            SetNewCollectionFormats(controlData);
            nakedObject.SetNotQueryable(true);

            if (controlData.SubAction == ObjectAndControlData.SubActionType.Cancel &&
                nakedObject.ResolveState.IsTransient() &&
                nakedObject.Specification.Persistable == Persistable.USER_PERSISTABLE) {
                // remove from cache and return to last object 
                Session.RemoveFromCache(nakedObject, ObjectCache.ObjectFlag.BreadCrumb);
                return AppropriateView(controlData, null);
            }
            string property = DisplaySingleProperty(controlData, controlData.DataDict);
            return AppropriateView(controlData, nakedObject, null, property);
        }
 public override ActionResult Cancel(string nextId, ObjectAndControlData controlData) {
     return base.Cancel(nextId, controlData);
 }
예제 #10
0
        internal INakedObject FilterCollection(INakedObject nakedObject, ObjectAndControlData controlData) {
            var form = controlData.Form;
            if (form != null && nakedObject != null && nakedObject.Specification.IsCollection && nakedObject.Oid is CollectionMemento) {
                nakedObject = Page(nakedObject, nakedObject.GetAsQueryable().Count(), controlData, false);
                var map = nakedObject.GetAsEnumerable().ToDictionary(FrameworkHelper.GetObjectId, y => y.Object);
                var selected = map.Where(kvp => form.Keys.Cast<string>().Contains(kvp.Key) && form[kvp.Key].Contains("true")).Select(kvp => kvp.Value).ToArray();
                return CloneAndPopulateCollection(nakedObject, selected, false);
            }

            return nakedObject;
        }
 public override ActionResult ClearHistoryItem(string id, string nextId, ObjectAndControlData controlData) {
     return base.ClearHistoryItem(id, nextId, controlData);
 }
예제 #12
0
 internal static int GetPageSize(ObjectAndControlData controlData) {
     if (controlData.DataDict.ContainsKey(IdHelper.PageSizeKey)) {
         return int.Parse(controlData.DataDict[IdHelper.PageSizeKey]);
     }
     if (!string.IsNullOrEmpty(controlData.PageSize)) {
         return int.Parse(controlData.PageSize);
     }
     INakedObjectAction action = controlData.GetAction();
     return action != null ? action.GetFacet<IPageSizeFacet>().Value : 0;
 }
예제 #13
0
        internal INakedObject Page(INakedObject nakedObject, int collectionSize, ObjectAndControlData controlData, bool forceEnumerable) {
            int page, pageSize;
            var collectionfacet = nakedObject.GetCollectionFacetFromSpec();
            if (CurrentlyPaging(controlData, collectionSize, out page, out pageSize) && !nakedObject.IsPaged()) {
                return DoPaging(nakedObject, collectionfacet, page, pageSize, forceEnumerable);
            }

            // one page of full collection 
            return DoPaging(nakedObject, collectionfacet, 1, collectionSize, forceEnumerable);
        }
 public override ActionResult EditObject(ObjectAndControlData controlData)
 {
     return base.EditObject(controlData);
 }
예제 #15
0
        internal void CheckConcurrency(INakedObject nakedObject, INakedObjectAssociation parent, ObjectAndControlData controlData, Func<INakedObjectAssociation, INakedObject, INakedObjectAssociation, string> idFunc) {
            var concurrencyFields = nakedObject.Specification.Properties.Where(p => p.ContainsFacet<IConcurrencyCheckFacet>()).ToList();

            if (!nakedObject.ResolveState.IsTransient() && concurrencyFields.Any() ) {
                IEnumerable<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues = GetFieldsAndMatchingValues(nakedObject, parent, concurrencyFields, controlData, idFunc);

                foreach (var pair in fieldsAndMatchingValues) {
                    if (pair.Item1.Specification.IsParseable) {
                        INakedObject currentValue = pair.Item1.GetNakedObject(nakedObject);
                        INakedObject concurrencyValue = pair.Item1.Specification.GetFacet<IParseableFacet>().ParseInvariant(pair.Item2 as string);

                        if (concurrencyValue != null && currentValue != null) {
                            if (concurrencyValue.TitleString() != currentValue.TitleString()) {
                                throw new ConcurrencyException(nakedObject, null);
                            }
                        }
                        else if (concurrencyValue == null && currentValue == null) {
                            // OK 
                        }
                        else {
                            throw new ConcurrencyException(nakedObject, null);
                        }
                    }
                }
            }
        }
 public override ActionResult ClearHistoryOthers(string id, ObjectAndControlData controlData) {
     return base.ClearHistoryOthers(id, controlData);
 }
 public override ActionResult Details(ObjectAndControlData controlData)
 {
     return base.Details(controlData);
 }
예제 #18
0
        private static object GetValueFromForm(ObjectAndControlData controlData,  string name) {
            var form = controlData.Form;

            if (form.GetValue(name) != null) {
                return ((string[]) form.GetValue(name).RawValue).First();
            }

            return controlData.Files.ContainsKey(name) ? controlData.Files[name] : null;
        }
예제 #19
0
        internal void AddAttemptedValues(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent = null) {
          
            foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(p => (IsUsable(p, nakedObject) && IsVisible(p, nakedObject)) || IsConcurrency(p))) {
                string name = GetFieldInputId(parent, nakedObject, assoc);
                string value = GetValueFromForm(controlData, name) as string;
                if (value != null) {
                    AddAttemptedValue(name, value);
                }
            }

            foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(IsConcurrency)) {             
                string name = GetConcurrencyFieldInputId(parent, nakedObject, assoc);
                string value = GetValueFromForm(controlData, name) as string; 
                if (value != null) {
                    AddAttemptedValue(name, value);
                }
            }

            foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(p => p.IsInline)) {
                var inlineNakedObject = assoc.GetNakedObject(nakedObject);
                AddAttemptedValues(inlineNakedObject, controlData, assoc);
            }

        }
예제 #20
0
 private static IEnumerable<Tuple<INakedObjectAssociation, object>> GetFieldsAndMatchingValues(INakedObject nakedObject,
                                                                                               INakedObjectAssociation parent,
                                                                                               IEnumerable<INakedObjectAssociation> associations,                                                                                                      
                                                                                               ObjectAndControlData controlData, 
                                                                                               Func<INakedObjectAssociation, INakedObject, INakedObjectAssociation, string> idFunc) {
                
     foreach (INakedObjectAssociation assoc in associations.Where(a => !a.IsInline)) {
         string name = idFunc(parent, nakedObject, assoc);
         object newValue = GetValueFromForm(controlData, name);
         yield return new Tuple<INakedObjectAssociation, object>(assoc, newValue);
     }
 }
예제 #21
0
        internal bool ApplyChanges(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent = null) {
            List<INakedObjectAssociation> usableAndVisibleFields;
            List<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues;
            GetUsableAndVisibleFields(nakedObject, controlData, parent, out usableAndVisibleFields, out fieldsAndMatchingValues);

            foreach (var pair in fieldsAndMatchingValues) {
                INakedObject value = GetNakedObjectValue(pair.Item1, nakedObject, pair.Item2);
                if (!pair.Item1.IsCollection) {
                    SetAssociation(nakedObject, (IOneToOneAssociation)pair.Item1, value, pair.Item2);
                }
            }

            ValidateOrApplyInlineChanges(nakedObject, controlData, nakedObject.Specification.Properties, ApplyChanges);

            if (nakedObject.ResolveState.IsTransient()) {
                CanPersist(nakedObject, usableAndVisibleFields);
                if (ModelState.IsValid) {
                    if (nakedObject.Specification.Persistable == Persistable.USER_PERSISTABLE) {
                        NakedObjectsContext.ObjectPersistor.MakePersistent(nakedObject);
                    }
                    else {
                        NakedObjectsContext.ObjectPersistor.ObjectChanged(nakedObject);
                    }
                }
            }

            return ModelState.IsValid;
        }
예제 #22
0
 private static void GetUsableAndVisibleFields(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent, out List<INakedObjectAssociation> usableAndVisibleFields, out List<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues) {
     usableAndVisibleFields = nakedObject.Specification.Properties.Where(p => IsUsable(p, nakedObject) && IsVisible(p, nakedObject)).ToList();
     fieldsAndMatchingValues = GetFieldsAndMatchingValues(nakedObject, parent, usableAndVisibleFields, controlData, GetFieldInputId).ToList();
 }
예제 #23
0
        private void ValidateOrApplyInlineChanges(INakedObject nakedObject, ObjectAndControlData controlData, IEnumerable<INakedObjectAssociation> assocs, Func<INakedObject, ObjectAndControlData, INakedObjectAssociation, bool> validateOrApply) {

            var form = controlData.Form;
            // inline or one or more keys in form starts with the property id which indicates we have nested values for the subobject 
            foreach (INakedObjectAssociation assoc in assocs.Where(a => a.IsInline || form.AllKeys.Any(k => k.KeyPrefixIs(a.Id)))) {
                INakedObject inlineNakedObject = assoc.GetNakedObject(nakedObject);
                if (inlineNakedObject != null) {
                    validateOrApply(inlineNakedObject, controlData, assoc);
                }
            }
        }
예제 #24
0
        internal bool ValidateChanges(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent = null) {
            List<INakedObjectAssociation> usableAndVisibleFields;
            List<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues;
            GetUsableAndVisibleFields(nakedObject, controlData, parent, out usableAndVisibleFields, out fieldsAndMatchingValues);

            CheckConcurrency(nakedObject, parent, controlData, GetConcurrencyFieldInputId);

            fieldsAndMatchingValues.ForEach(pair => AddAttemptedValue(GetFieldInputId(parent, nakedObject, pair.Item1), pair.Item2));

            // check mandatory fields first to emulate WPF UI behaviour where no validation takes place until 
            // all mandatory fields are set. 
            foreach (var pair in fieldsAndMatchingValues) {
                var result = pair.Item2;
                var stringResult = result as string;

                if (pair.Item1.IsMandatory && (result == null || (result is string && string.IsNullOrEmpty(stringResult)))) {
                    AddErrorAndAttemptedValue(nakedObject, stringResult, pair.Item1, MvcUi.Mandatory, parent);
                }
            }

            if (ModelState.IsValid) {
                ValidateOrApplyInlineChanges(nakedObject, controlData, usableAndVisibleFields, ValidateChanges);
            }

            if (ModelState.IsValid) {
                foreach (var pair in fieldsAndMatchingValues) {
                    if (!pair.Item1.IsCollection) {
                        ValidateAssociation(nakedObject, (IOneToOneAssociation) pair.Item1, pair.Item2, parent);
                    }
                }
            }

            if (ModelState.IsValid) {
                INakedObjectValidation[] validators = nakedObject.Specification.ValidateMethods();

                foreach (INakedObjectValidation validator in validators) {
                    string[] parmNames = validator.ParameterNames;
                 
                    var matchingparms = parmNames.Select(pn => fieldsAndMatchingValues.Single(t => t.Item1.Id.ToLower() == pn)).ToList();

                    if (matchingparms.Count() == parmNames.Count()) {
                        string result = validator.Execute(nakedObject, matchingparms.Select(t => GetNakedObjectValue(t.Item1, nakedObject, t.Item2)).ToArray());

                        if (!string.IsNullOrEmpty(result)) {                         
                            ModelState.AddModelError(string.Empty, result);
                        }
                    }
                }
            }

            if (ModelState.IsValid) {
                if (nakedObject.Specification.ContainsFacet<IValidateProgrammaticUpdatesFacet>()) {
                    string state = nakedObject.ValidToPersist();
                    if (state != null) {
                        ModelState.AddModelError(string.Empty, state);
                    }
                }
            }

            return ModelState.IsValid;
        }
 public override ActionResult Action(ObjectAndControlData controlData)
 {
     return base.Action(controlData);
 }
예제 #26
0
 internal void SetPagingValues(ObjectAndControlData controlData, INakedObject nakedObject) {
     if (nakedObject.Specification.IsCollection) {
         int sink1, sink2;
         CurrentlyPaging(controlData, nakedObject.GetAsEnumerable().Count(), out sink1, out sink2);
     }
 }
 public override ActionResult Details(ObjectAndControlData controlData, FormCollection form)
 {
     return base.Details(controlData, form);
 }
예제 #28
0
        internal bool CurrentlyPaging(ObjectAndControlData controlData, int collectionSize, out int page, out int pageSize) {
            pageSize = GetPageSize(controlData);
            page = 1;

            if (pageSize > 0) {
                page = GetPage(controlData);

                var pagingData = new Dictionary<string, int> {
                                                                 {IdHelper.PagingCurrentPage, page},
                                                                 {IdHelper.PagingPageSize, pageSize},
                                                                 {IdHelper.PagingTotal, collectionSize}
                                                             };
                ViewData[IdHelper.PagingData] = pagingData;
                return true;
            }

            return false;
        }
 public override ActionResult EditObject(ObjectAndControlData controlData, FormCollection form)
 {
     return base.EditObject(controlData, form);
 }
예제 #30
0
 private static int GetPage(ObjectAndControlData controlData) {
     if (controlData.DataDict.ContainsKey(IdHelper.PageKey)) {
         return int.Parse(controlData.DataDict[IdHelper.PageKey]);
     }
     return !string.IsNullOrEmpty(controlData.Page) ? int.Parse(controlData.Page) : 1;
 }