Example #1
0
 public override Dictionary<string, object> GetJsonClientFormFieldSchema(SPControlMode mode)
 {
     var formtctx = base.GetJsonClientFormFieldSchema(mode);
     formtctx["ValidRegExp"] = ValidRegExp;
     formtctx["ErrorMessage"] = ErrorMessage;
     return formtctx;
 }
        public override Dictionary <string, object> GetJsonClientFormFieldSchema(SPControlMode mode)
        {
            var formctx = base.GetJsonClientFormFieldSchema(mode);

            formctx["artDevContent"] = ((ArtDevLookupFieldControl)fieldControl).ListName;
            return(formctx);
        }
Example #3
0
        protected override void CreateChildControls()
        {
            if (SPContext.Current.SiteFeatures[new Guid(Constants.ASPLFeature.FeatureID)] == null)
            {
                base.CreateChildControls(); return;
            }

            this.Controls.Clear();

            try
            {
                if (this.ControlTemplate == null)
                {
                    throw new ArgumentException("Could not find ListFieldIterator control template.");
                }

                AddLiteralControl(RendringUtil.RenderTabs(allTabs));

                string allFields = string.Empty;

                for (int i = 0; i < base.Fields.Count; i++)
                {
                    SPField       spField       = base.Fields[i];
                    SPControlMode ctrlMode      = SPControlMode.Invalid;
                    bool          isFieldHidden = false;

                    // Permission matrix execution...

                    ctrlMode = PermissionHandler.Handle(spField.InternalName, this.ControlMode, allTabs, allFieldPermissions, SPContext.Current.Web.CurrentUser, out isFieldHidden);

                    if (this.ControlMode == SPControlMode.New && allFieldDefaults != null)
                    {
                        RendringUtil.SetDefault(spField, allFieldDefaults);
                    }

                    if (!this.IsFieldExcluded(spField) && !spField.Hidden && !spField.ReadOnlyField && !isFieldHidden)
                    {
                        ASPLTemplateContainer tempCon = new ASPLTemplateContainer();
                        this.Controls.Add(tempCon.Template);
                        tempCon.FieldName   = spField.InternalName;
                        tempCon.ControlMode = ctrlMode;
                        this.ControlTemplate.InstantiateIn(tempCon.Template);
                        allFields += "'" + spField.InternalName + "~Show',";
                        LiteralControl templateTR = tempCon.Controls[0] as LiteralControl;
                        templateTR.Text = templateTR.Text.Replace("tr", "tr id='" + spField.InternalName + "~Show" + "'");
                    }
                }

                AddLiteralControl("<script type='text/javascript'> var allFieldsArray = new Array(" + allFields.Trim(',') + ");</script>");
            }
            catch (Exception exp)
            {
                this.Controls.Clear();
                base.CreateChildControls();
                Logging.Log(exp);
            }
        }
Example #4
0
 private static void SetControlMode(TemplateContainer child, SPControlMode controlMode)
 {
     try
     {
         PropertyInfo property = child.GetType().GetProperty("ControlMode", BindingFlags.NonPublic | BindingFlags.Instance);
         property.SetValue(child, controlMode, null);
     }
     catch (Exception) { }
 }
 public static void SetFormTempalteName(this SPContentType contentType, SPControlMode controlMode, string templateName) {
     contentType.ParentWeb.AllowUnsafeUpdates = true;
     switch (controlMode) {
         case SPControlMode.New:
             contentType.NewFormTemplateName = templateName;
             break;
         case SPControlMode.Edit:
             contentType.EditFormTemplateName = templateName;
             break;
         case SPControlMode.Display:
             contentType.DisplayFormTemplateName = templateName;
             break;
         default:
             break;
     }
     contentType.Update();
     contentType.ParentWeb.AllowUnsafeUpdates = false;
 }
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            this.PickerDialogType = typeof(GenericPickerDialog);
            propBag = new GenericEntityPickerPropertyBag(this.CustomProperty);

            if (SPContext.Current.FormContext.FormMode != SPControlMode.Invalid)
            {
                mode = SPContext.Current.FormContext.FormMode;
            }
            else
            {
                try
                {
                    mode = (SPControlMode)int.Parse(Page.Request["mode"]);
                }
                catch { }
            }
        }
 public static void SetFormTempalteName(this SPList list, SPControlMode controlMode, string templateName) {
     var pageType = PAGETYPE.PAGE_NEWFORM;
     switch (controlMode) {
         case SPControlMode.New:
             pageType = PAGETYPE.PAGE_NEWFORM;
             break;
         case SPControlMode.Edit:
             pageType = PAGETYPE.PAGE_EDITFORM;
             break;
         case SPControlMode.Display:
             pageType = PAGETYPE.PAGE_DISPLAYFORM;
             break;
         default:
             break;
     }
     var form = list.Forms.Cast<SPForm>().Where(f => f.Type == pageType).FirstOrDefault();
     if (form == null)
         throw new ArgumentOutOfRangeException("PAGETYPE");
     var file = list.ParentWeb.GetFile(list.ParentWeb.Url + "/" + form.Url);
     if (file.CheckOutType == SPFile.SPCheckOutType.None) {
         list.ParentWeb.AllowUnsafeUpdates = true;
         file.CheckOut();
         using (SPLimitedWebPartManager webpartManager = file.GetLimitedWebPartManager(PersonalizationScope.Shared)) {
             foreach (System.Web.UI.WebControls.WebParts.WebPart webpart in webpartManager.WebParts) {
                 if (webpart is ListFormWebPart) {
                     ListFormWebPart listFormWebPart = (ListFormWebPart)webpart;
                     listFormWebPart.TemplateName = templateName;
                     webpartManager.SaveChanges(listFormWebPart);
                     break;
                 }
             }
             file.Update();
         }
         file.CheckIn("Fabric UI");
         list.ParentWeb.AllowUnsafeUpdates = false;
     } else {
         throw new SPFileCheckOutException(file, form.Url + " has been CheckOut", 0, SPFileCheckOutExceptionType.OnlineCheckOutExists);
     }
 }
        private void SaveToProperties(SPList currentList, SPField currentField, SPControlMode controlMode, string fieldStatus, string value, int clear)
        {
            try
            {
                StringBuilder propertyValue = new StringBuilder();
                propertyValue.Append(Definitions.prefix + Definitions.separator);
                propertyValue.Append(currentList.ID + Definitions.separator);
                propertyValue.Append(currentField.Id + Definitions.separator);
                propertyValue.Append(controlMode.ToString() + Definitions.separator);
                propertyValue.Append(fieldStatus);

                string propertyToSite = propertyValue.ToString();

                if (clear == 0)
                {
                    currentSite.RootWeb.AllProperties.Remove(propertyToSite);
                }
                else
                {
                    if (currentSite.RootWeb.AllProperties.ContainsKey(propertyToSite))
                    {
                        currentSite.RootWeb.AllProperties[propertyToSite] = value;
                    }
                    else
                    {
                        currentSite.RootWeb.AllProperties.Add(propertyToSite, value);
                    }
                }

                currentSite.RootWeb.Update();
                currentSite.RootWeb.Properties.Update();
            }
            catch (Exception ex)
            {
                errorText.Text = "Error on Save Column:<br />" + ex.Message;
            }
        }
Example #9
0
        private static Control CreateNumberFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            NumberField nf = new NumberField();

            nf.ListId      = list.ID;
            nf.ItemId      = item.ID;
            nf.FieldName   = field.Title;
            nf.ID          = field.Title;
            nf.ControlMode = mode;
            return(nf);
        }
Example #10
0
        private static Control CreateRadioButtonChoiceField(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            RadioButtonChoiceField rbcf = new RadioButtonChoiceField();

            rbcf.ListId      = list.ID;
            rbcf.ItemId      = item.ID;
            rbcf.FieldName   = field.Title;
            rbcf.ID          = field.Title;
            rbcf.ControlMode = mode;
            return(rbcf);
        }
Example #11
0
        private static Control CreateDropDownChoiceField(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            DropDownChoiceField ddcf = new DropDownChoiceField();

            ddcf.ListId      = list.ID;
            ddcf.ItemId      = item.ID;
            ddcf.FieldName   = field.Title;
            ddcf.ID          = field.Title;
            ddcf.ControlMode = mode;
            return(ddcf);
        }
Example #12
0
        private static Control CreateRichTextFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            RichTextField rtf = new RichTextField();

            rtf.ListId      = list.ID;
            rtf.ItemId      = item.ID;
            rtf.FieldName   = field.Title;
            rtf.ID          = field.Title;
            rtf.ControlMode = mode;
            return(rtf);
        }
Example #13
0
        public static Control GetSharePointControls(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            // check if the field is a buildIn field, or a can be rendered by a SharePoint Control
            if (field.FieldRenderingControl == null)
            {
                return(null);
            }

            switch (field.FieldRenderingControl.ToString())
            {
            case "Microsoft.SharePoint.WebControls.TextField":
                return(CreateTextFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.NoteField":
                return(CreateNoteFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.RichTextField":
                return(CreateRichTextFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.DropDownChoiceField":
                return(CreateDropDownChoiceField(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.RadioButtonChoiceField":
                return(CreateRadioButtonChoiceField(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.NumberField":
                return(CreateNumberFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.CurrencyField":
                return(CreateCurrencyFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.DateTimeField":
                return(CreateDateTimeFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.LookupField":
                return(CreateLookupFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.MultipleLookupField":
                return(CreateMultipleLookupFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.BooleanField":
                return(CreateBooleanField(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.UserField":
                return(CreateUserFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.UrlField":
                return(CreateUrlFieldControl(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.ComputedField":
                return(CreateComputedFieldCotnrol(field, list, item, mode));

            case "Microsoft.SharePoint.WebControls.AttachmentsField":
                return(CreateAttachmentsFieldControl(field, list, item, mode));

            default:
                break;
            }

            return(null);
        }
        private string SelectFromProperties(SPList currentList, SPField currentField, SPControlMode controlMode, string fieldStatus)
        {
            try
            {
                StringBuilder propertyValue = new StringBuilder();
                propertyValue.Append(Definitions.prefix + Definitions.separator);
                propertyValue.Append(currentList.ID + Definitions.separator);
                propertyValue.Append(currentField.Id + Definitions.separator);
                propertyValue.Append(controlMode.ToString() + Definitions.separator);
                propertyValue.Append(fieldStatus);

                string propertyToSite = propertyValue.ToString();

                if (currentSite.RootWeb.AllProperties.ContainsKey(propertyToSite))
                {
                    return(currentSite.RootWeb.AllProperties[propertyToSite].ToString());
                }
                else
                {
                    return(String.Empty);
                }
            }
            catch (Exception ex)
            {
                errorText.Text = "Error on Load Column:<br />" + ex.Message;
                return(String.Empty);
            }
        }
Example #15
0
        private static Control CreateMultipleLookupFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            MultipleLookupField mlf = new MultipleLookupField();

            mlf.ListId      = list.ID;
            mlf.ItemId      = item.ID;
            mlf.FieldName   = field.Title;
            mlf.ID          = field.Title;
            mlf.ControlMode = mode;
            return(mlf);
        }
Example #16
0
        private static Control CreateComputedFieldCotnrol(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            ComputedField cf = new ComputedField();

            cf.ListId      = list.ID;
            cf.ItemId      = item.ID;
            cf.FieldName   = field.Title;
            cf.ID          = field.Title;
            cf.ControlMode = mode;
            return(cf);
        }
Example #17
0
        private static Control CreateUserFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            UserField uf = new UserField();

            uf.ListId    = list.ID;
            uf.ItemId    = item.ID;
            uf.FieldName = field.Title;
            // Replace blanks/@ with _ so that the control still works
            uf.ID          = field.Title.Replace(' ', '_').Replace('@', '_');
            uf.ControlMode = mode;
            return(uf);
        }
        public bool  GetFieldPermissionForCurrentUser(SPField field, string fieldStatus, SPControlMode controlFormMode, bool isViewOrAlert, SPUser spUser, SPSite spSite)
        {
            try {
                //MUSIM to robit pretoze SPContext je NULL ked sa jedna o alert pretoze predsa timerjob spusta alerty!
                if (spSite == null)
                {
                    currentSite = SPContext.Current.Site;
                    currentWeb  = SPContext.Current.Web;
                }
                else
                {
                    currentSite = spSite;
                    currentWeb  = currentSite.OpenWeb();
                }

                //Kedze sa tato metoda vola vzdy tak tu prepisem usera ktory ju vola pretoze pri alertoch je potrebne vediet uzivatela ktory vytvoril dany alert a nie prihlasenho uzivatela
                currentUser = spUser; //Je to globalny objekt preto ho inicializujem az tu!!!

                string propertyValue = GetValueFromProperty(field, fieldStatus, controlFormMode, isViewOrAlert);

                if (propertyValue != String.Empty)
                {
                    //Uz sa to uklada inak cez ciarku a bez 8;# atd
                    //string docasnyZoznam = "8;#tester1;#9;#tester10;#4;#Intranet – návštevníci;#10;#tester2;#5;#Intranet – členovia;#9;#sp2010\\Administrator";
                    //string docasnyZoznamAD = "8;#sp2010\\group1;#9;#shpgroup1;#9;#tester10";

                    if (IsUserIncludedInProperties(propertyValue))
                    {
                        ClearAllLists();

                        if (ViceVersaSetting(currentSite, field.ParentList, false))
                        {
                            return(false);
                        }
                        else
                        {
                            return(true);
                        }
                    }
                    else
                    {
                        ClearAllLists();
                        if (ViceVersaSetting(currentSite, field.ParentList, false))
                        {
                            return(true);
                        }
                        else
                        {
                            return(false);
                        }
                    }
                }
                return(false);
            } catch (Exception ex) {
                //ToDo
                ClearAllLists();
                return(false);
            }
        }
Example #19
0
        public static SPControlMode Handle(string spInternalName,
            SPControlMode formMode, Tabs tabs, FieldPermissions fPerms,
            SPPrincipal princ, out bool isHidden)
        {
            SPControlMode result = SPControlMode.Invalid;
            isHidden = false;

            if (tabs != null)
            {
                foreach (Tab tab in tabs)
                {
                    foreach (TabPermission tp in tab.Permissions)
                    {
                        if (ConditionEvaluator.EvaluateFromListItem(tp.Conditions)
                            && PrincipalEvaluator.Check(tp.ForSPPrinciples,
                                tp.BySPPrinciplesOperator))
                        {
                            if (tab.Fields.Any<Field>
                                (f => f.SPName.Equals(spInternalName,
                                    StringComparison.InvariantCultureIgnoreCase)))
                            {
                                if (tp.OnForms.Contains(Enums.SPForms.New)
                                    && formMode == SPControlMode.New
                                        || tp.OnForms.Contains(Enums.SPForms.View)
                                        && formMode == SPControlMode.Display
                                            || tp.OnForms.Contains(Enums.SPForms.Edit)
                                            && formMode == SPControlMode.Edit)
                                {
                                    switch (tp.Level)
                                    {
                                        case Enums.PermissionLevel.Read:
                                            result = SPControlMode.Display; isHidden = false;
                                            break;

                                        case Enums.PermissionLevel.Write:

                                            if (formMode == SPControlMode.Edit)
                                                result = SPControlMode.Edit;
                                            else
                                                result = SPControlMode.New;

                                            isHidden = false;
                                            break;

                                        case Enums.PermissionLevel.Deny:
                                            isHidden = true;
                                            result = SPControlMode.Invalid;
                                            break;

                                    }
                                }
                            }
                        }
                    }
                }
            }

            //FieldPermissionCheck:
            if (fPerms != null)
            {
                foreach (FieldPermission fp in fPerms)
                {
                    if (ConditionEvaluator.EvaluateFromListItem(fp.Conditions)
                        && PrincipalEvaluator.Check(fp.ForSPPrinciples,
                            fp.BySPPrinciplesOperator))
                    {
                        if (fp.OnField.SPName.Equals(spInternalName,
                            StringComparison.InvariantCultureIgnoreCase))
                        {
                            if (fp.OnForms.Contains(Enums.SPForms.New)
                                && formMode == SPControlMode.New
                                    || fp.OnForms.Contains(Enums.SPForms.View)
                                    && formMode == SPControlMode.Display
                                        || fp.OnForms.Contains(Enums.SPForms.Edit)
                                        && formMode == SPControlMode.Edit)
                            {
                                switch (fp.Level)
                                {
                                    case Enums.PermissionLevel.Read:
                                        result = SPControlMode.Display; isHidden = false;
                                        goto FinishPermissionCheck;

                                    case Enums.PermissionLevel.Write:

                                        if (formMode == SPControlMode.Edit)
                                            result = SPControlMode.Edit;
                                        else
                                            result = SPControlMode.New;

                                        isHidden = false;
                                        goto FinishPermissionCheck;

                                    case Enums.PermissionLevel.Deny:
                                        isHidden = true;
                                        result = SPControlMode.Invalid;
                                        break;
                                }
                            }
                        }
                    }
                }
            }

        FinishPermissionCheck:
            return result;
        }
 protected virtual void Set(SPControlMode controlMode, FabricPageLayout pageLayout) {            
     ConfigManager configManager = new ConfigManager();
     if (List != null && ContentType != null) {
         ContentType.SetFormTempalteName(controlMode, "FabricListForm");
         //IPropertyBag propertyBag = configManager.GetPropertyBag(ConfigScope.List);
         IPropertyBag propertyBag = configManager.GetPropertyBag(ConfigScope.Web);
         configManager.SetPropertyBag("ListContentType" + List.ID.ToString() + ContentType.Id + controlMode, pageLayout, propertyBag);
     } else if (List != null) {
         List.SetFormTempalteName(controlMode, "FabricListForm");
         IPropertyBag propertyBag = configManager.GetPropertyBag(ConfigScope.Web);
         configManager.SetPropertyBag("List" + List.ID.ToString() + controlMode, pageLayout, propertyBag);
     } else if (ContentType != null) {
         ContentType.SetFormTempalteName(controlMode, "FabricListForm");
         //IPropertyBag propertyBag = configManager.GetPropertyBag(ConfigScope.List);
         IPropertyBag propertyBag = configManager.GetPropertyBag(ConfigScope.Web);
         configManager.SetPropertyBag("SiteContentType" + ContentType.Id + controlMode, pageLayout, propertyBag);
     }
 }
Example #21
0
        private static Control CreateDateTimeFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            DateTimeField dtc = new DateTimeField();

            dtc.ListId    = list.ID;
            dtc.ItemId    = item.ID;
            dtc.FieldName = field.Title;
            // Replace blanks with _ so that the control still works
            dtc.ID          = field.Title.Replace(' ', '_');
            dtc.ControlMode = mode;
            return(dtc);
        }
Example #22
0
        void WebSiteControllerModule_OnPreRequestHandlerExecute(object sender, EventArgs e)
        {
            application = sender as HttpApplication;

            string absolutePath = application.Request.Url.AbsolutePath.ToLower();

            if (absolutePath.Contains(".dll") ||
                absolutePath.Contains(".asmx") ||
                absolutePath.Contains(".svc") ||
                absolutePath.Contains(".axd") ||
                absolutePath.Contains(".ashx") ||
                absolutePath.Contains("favicon.ico"))
            {
                return;
            }

            HttpContext context = HttpContext.Current;

            /*
             * bool IsA = false;
             * if (context != null && context.User != null)
             * {
             *  IsA = context.User.Identity.IsAuthenticated;
             * }
             */

            SPContext _current = SPContext.Current;

            if (context != null && _current == null)
            {
                try
                {
                    if (!context.Request.FilePath.Contains("/_"))
                    {
                        _current = SPContext.GetContext(context);
                    }
                }
                catch { };
            }

            try
            {
                if (_current != null)
                {
                    bool          IsAuthenticated = HttpContext.Current.User.Identity.IsAuthenticated;
                    SPControlMode mode            = _current.FormContext.FormMode;
                    bool          isMode          = (mode == SPControlMode.Display || mode == SPControlMode.Invalid);

                    if (!IsAuthenticated && isMode)
                    {
                        bool isPage        = Hemrika.SharePresence.WebSite.Page.WebSitePage.IsWebSitePage(_current.ListItem);
                        bool isContentType = contentTypeFilter.IsMatch(context.Response.ContentType);
                        bool isMethod      = (context.Request.HttpMethod == "GET");

                        if (isMethod && isContentType && IsCompressionSupported(context))
                        {
                            //context.Items["filter"] = context.Response.Filter;
                            //WebPageProcessor.Compress(context);
                        }


                        //context.Response.Filter = new WebPageScriptFilter(context.Response);
                        //context.Response.Filter = new WebPageViewStateFilter(context.Response);
                        //context.Response.Filter = new WebPageWhiteSpaceFilter(context.Response);
                    }
                }
            }
            catch (Exception ex)
            {
                ex.ToString();
            }
        }
Example #23
0
        private static Control CreateLookupFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            LookupField lf = new LookupField();

            lf.ListId      = list.ID;
            lf.ItemId      = item.ID;
            lf.FieldName   = field.Title;
            lf.ID          = field.Title;
            lf.ControlMode = mode;
            return(lf);
        }
        public string GetValueFromProperty(SPField field, string fieldStatus, SPControlMode controlMode, bool isViewOrAlert)
        {
            SPList  currentList;
            SPItem  currentItem;
            SPField currentField;

            if (isViewOrAlert)
            {
                currentList  = field.ParentList;
                currentField = field;
            }
            else
            {
                BaseFieldControl webControl = field.FieldRenderingControl;
                currentList  = webControl.List;
                currentItem  = webControl.Item;
                currentField = webControl.Field;

                Guid?  currentListId    = webControl.ListId;
                int?   currentItemIdInt = webControl.ItemId;
                string currentItemId    = webControl.Field.Id.ToString();
                string currentValue     = webControl.ItemFieldValue == null ? "" : webControl.ItemFieldValue.ToString();
            }


            StringBuilder propertyValue = new StringBuilder();

            propertyValue.Append(Definitions.prefix + Definitions.separator);
            propertyValue.Append(currentList.ID + Definitions.separator);
            propertyValue.Append(currentField.Id + Definitions.separator);
            propertyValue.Append(controlMode.ToString() + Definitions.separator);
            propertyValue.Append(fieldStatus);

            //SPGuys_ListId_FieldId_FormMode_ReadOnly Hidden
            string propertyFromWeb = propertyValue.ToString();

            //SPGuys_b9a223e1-58da-4608-aaf4-0a0c2f1d6b0e_fa564e0f-0c70-4ab9-b863-0177e6ddd247_New_Hidden   title
            //SPGuys_b9a223e1-58da-4608-aaf4-0a0c2f1d6b0e_6e180dd1-762e-46a0-8ffd-7925b70e699e_New_ReadOnly   people

            if (propertyFromWeb.Contains(SPBuiltInFieldId.LinkTitle.ToString()))
            {
                propertyFromWeb = propertyFromWeb.Replace(SPBuiltInFieldId.LinkTitle.ToString(), SPBuiltInFieldId.Title.ToString());
            }

            if (propertyFromWeb.Contains(SPBuiltInFieldId.LinkTitleNoMenu.ToString()))
            {
                propertyFromWeb = propertyFromWeb.Replace(SPBuiltInFieldId.LinkTitleNoMenu.ToString(), SPBuiltInFieldId.Title.ToString());
            }

            //Toto tu je kvoli tomu ze ked volam priamo tuto metodu na zistenie detailov pre ListField.aspx
            if (currentSite == null)
            {
                currentSite = SPContext.Current.Site;
                currentWeb  = SPContext.Current.Web;
            }

            if (currentSite.RootWeb.AllProperties[propertyFromWeb] != null)
            {
                //Musim replacovat \\\\ aj ked do property ulozim len \\ ale on tam doplni \\ potrebujem to mat v stave sp2010\\Administrator nie sp2010\\\\Administrator
                //return currentSite.RootWeb.AllProperties[propertyFromWeb].ToString().Replace("\\\\", "\\");

                return(currentSite.RootWeb.AllProperties[propertyFromWeb].ToString()); //Tu sa to zapisuje inak preto nam to nie je treba replacovat
            }

            return(String.Empty);
        }
Example #25
0
        private static Control CreateBooleanField(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            BooleanField bf = new BooleanField();

            bf.ListId      = list.ID;
            bf.ItemId      = item.ID;
            bf.FieldName   = field.Title;
            bf.ID          = field.Title;
            bf.ControlMode = mode;
            return(bf);
        }
 protected virtual bool IsFieldExcluded(SPControlMode controlMode, SPField field) {
     var fieldIterator = new ListFieldIterator();
     fieldIterator.ControlMode = controlMode;
     MethodInfo IsFieldExcluded = typeof(ListFieldIterator).GetMethod("IsFieldExcluded", BindingFlags.NonPublic | BindingFlags.Instance);
     return (bool)IsFieldExcluded.Invoke(fieldIterator, new object[] { field });
 }
Example #27
0
        private static Control CreateUrlFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            UrlField urlf = new UrlField();

            urlf.ListId      = list.ID;
            urlf.ItemId      = item.ID;
            urlf.FieldName   = field.Title;
            urlf.ID          = field.Title;
            urlf.ControlMode = mode;
            return(urlf);
        }
Example #28
0
        void EnsureFormContext()
        {
            if ((this.m_itemContext == null) && (this.Context != null))
            {
                if (base.List == null)
                {
                    throw new SPException(SPResource.GetString("ListWithTitleDoesNotExist", new object[] { base.ListName }));
                }

                if (Page.Request.QueryString["ID"] != null)
                {
                    //if (this.CurListItemId <= 0)
                    this.CurListItemId = Convert.ToInt32(Page.Request.QueryString["ID"]);

                    if (this.FormMode == SPControlMode.Invalid)
                        this.FormMode = SPControlMode.Display ;
                }
                else
                {
                    if (this.FormMode == SPControlMode.Invalid)
                        this.FormMode = SPControlMode.New ;
                }

                this.m_itemContext = SPContext.GetContext(this.Context, this.CurListItemId, this.List.ID, base.Web);

                if (this._FormMode == SPControlMode.Invalid)
                {
                    this._FormMode = this.m_itemContext.FormContext.FormMode;
                }
                else
                {
                    this.m_itemContext.FormContext.FormMode = this.FormMode;
                    //this.m_itemContext.FormContext.DisableInitialFocus = this.DisableInitialFocus;
                    this.m_itemContext.FormContext.SetFormMode(this.FormMode, true);
                }
            }
        }
Example #29
0
        private static Control CreateAttachmentsFieldControl(SPField field, SPList list, SPListItem item, SPControlMode mode)
        {
            AttachmentsField af = new AttachmentsField();

            af.ListId      = list.ID;
            af.ItemId      = item.ID;
            af.FieldName   = field.Title;
            af.ID          = field.Title;
            af.ControlMode = mode;
            return(af);
        }
        public static SPControlMode Handle(string spInternalName,
                                           SPControlMode formMode, Tabs tabs, FieldPermissions fPerms,
                                           SPPrincipal princ, out bool isHidden)
        {
            SPControlMode result = SPControlMode.Invalid;

            isHidden = false;

            if (tabs != null)
            {
                foreach (Tab tab in tabs)
                {
                    foreach (TabPermission tp in tab.Permissions)
                    {
                        if (ConditionEvaluator.EvaluateFromListItem(tp.Conditions) &&
                            PrincipalEvaluator.Check(tp.ForSPPrinciples,
                                                     tp.BySPPrinciplesOperator))
                        {
                            if (tab.Fields.Any <Field>
                                    (f => f.SPName.Equals(spInternalName,
                                                          StringComparison.InvariantCultureIgnoreCase)))
                            {
                                if (tp.OnForms.Contains(Enums.SPForms.New) &&
                                    formMode == SPControlMode.New ||
                                    tp.OnForms.Contains(Enums.SPForms.View) &&
                                    formMode == SPControlMode.Display ||
                                    tp.OnForms.Contains(Enums.SPForms.Edit) &&
                                    formMode == SPControlMode.Edit)
                                {
                                    switch (tp.Level)
                                    {
                                    case Enums.PermissionLevel.Read:
                                        result = SPControlMode.Display; isHidden = false;
                                        break;

                                    case Enums.PermissionLevel.Write:

                                        if (formMode == SPControlMode.Edit)
                                        {
                                            result = SPControlMode.Edit;
                                        }
                                        else
                                        {
                                            result = SPControlMode.New;
                                        }

                                        isHidden = false;
                                        break;

                                    case Enums.PermissionLevel.Deny:
                                        isHidden = true;
                                        result   = SPControlMode.Invalid;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            //FieldPermissionCheck:
            if (fPerms != null)
            {
                foreach (FieldPermission fp in fPerms)
                {
                    if (ConditionEvaluator.EvaluateFromListItem(fp.Conditions) &&
                        PrincipalEvaluator.Check(fp.ForSPPrinciples,
                                                 fp.BySPPrinciplesOperator))
                    {
                        if (fp.OnField.SPName.Equals(spInternalName,
                                                     StringComparison.InvariantCultureIgnoreCase))
                        {
                            if (fp.OnForms.Contains(Enums.SPForms.New) &&
                                formMode == SPControlMode.New ||
                                fp.OnForms.Contains(Enums.SPForms.View) &&
                                formMode == SPControlMode.Display ||
                                fp.OnForms.Contains(Enums.SPForms.Edit) &&
                                formMode == SPControlMode.Edit)
                            {
                                switch (fp.Level)
                                {
                                case Enums.PermissionLevel.Read:
                                    result = SPControlMode.Display; isHidden = false;
                                    goto FinishPermissionCheck;

                                case Enums.PermissionLevel.Write:

                                    if (formMode == SPControlMode.Edit)
                                    {
                                        result = SPControlMode.Edit;
                                    }
                                    else
                                    {
                                        result = SPControlMode.New;
                                    }

                                    isHidden = false;
                                    goto FinishPermissionCheck;

                                case Enums.PermissionLevel.Deny:
                                    isHidden = true;
                                    result   = SPControlMode.Invalid;
                                    break;
                                }
                            }
                        }
                    }
                }
            }

FinishPermissionCheck:
            return(result);
        }