void SaveAsso1()
        {
            ISharePointService sps = ServiceFactory.GetSharePointService(true);

            SPList list = sps.GetList(CAWorkFlowConstants.WorkFlowListName.StoreMaintenanceItems1.ToString());

            foreach (DataRow row in this.DataForm1.Asso1.Rows)
            {
                SPListItem item = list.Items.Add();
                item["WorkflowNumber"] = DataForm1.WorkflowNumber;
                item["Seq"] = row["Seq"];
                item["Reason"] = row["Reason"];
                item["Description"] = row["Description"];
                item["Remark"] = row["Remark"];
                try
                {
                    using (SPSite site = new SPSite(SPContext.Current.Site.ID))
                    {
                        using (SPWeb web = site.OpenWeb(SPContext.Current.Site.RootWeb.ID))
                        {
                            item.Web.AllowUnsafeUpdates = true;
                            item.Update();
                            item.Web.AllowUnsafeUpdates = false;
                        }
                    }
                }
                catch (Exception ex)
                {
                    Response.Write("An error occured while updating the items");
                }

                //item.Web.AllowUnsafeUpdates = true;
                //item.Update();
            }
        }

        public System.Collections.Specialized.StringCollection GetSPChoiceFieldValue(string listName, string fieldName)
        {
            SPContext context = SPContext.Current;
            StringCollection fieldChoices = null;

            SPSecurity.RunWithElevatedPrivileges(delegate
            {
                using (SPSite site = new SPSite(context.Site.ID))
                {
                    using (SPWeb web = site.OpenWeb(context.Web.ID))
                    {
                        SPList list = web.Lists[listName];
                        SPField field = list.Fields[fieldName] as SPField;

                        if (field != null
                            && field.Type == SPFieldType.Choice)
                        {

                            fieldChoices = (field as SPFieldChoice).Choices;
                        }
                    }
                }
            });

            return fieldChoices;
        }

        /// <summary>
        /// Runs the specified command.
        /// </summary>
        /// <param name="command">The command.</param>
        /// <param name="keyValues">The key values.</param>
        /// <param name="output">The output.</param>
        /// <returns></returns>
        public override int Execute(string command, StringDictionary keyValues, out string output)
        {
            output = string.Empty;

            string url = Params["url"].Value.TrimEnd('/');

            using (SPSite site = new SPSite(url))
            {
                using (SPWeb web = site.AllWebs[Utilities.GetServerRelUrlFromFullUrl(url)])
                {

                    foreach (SPLanguage lang in web.RegionalSettings.InstalledLanguages)
                    {
                        foreach (SPWebTemplate template in site.GetWebTemplates((uint)lang.LCID))
                        {
                            output += template.Name + " = " + template.Title + " (" + lang.LCID + ")\r\n";
                        }
                        foreach (SPWebTemplate template in site.GetCustomWebTemplates((uint)lang.LCID))
                        {
                            output += template.Name + " = " + template.Title + " (Custom)(" + lang.LCID + ")\r\n";
                        }
                    }
                }
            }

            return (int)ErrorCodes.NoError;
        }

        static void Main(string[] args)
        {
            using (SPSite site = new SPSite("http://sam2012:33333"))
            {
                using (SPWeb web = site.OpenWeb("/sub"))
                {
                    web.AnonymousPermMask64 |= SPBasePermissions.UseRemoteAPIs;//SPBasePermissions.OpenItems;
                    Console.Write(web.AnonymousPermMask64);
                    Console.Write(web.DoesUserHavePermissions(SPBasePermissions.AddListItems));
                    SPList list = web.Lists["Temp"];
                    bool addItemPerm = list.DoesUserHavePermissions(SPBasePermissions.AddListItems);
                    Console.WriteLine(addItemPerm);
                    Console.WriteLine(list.AnonymousPermMask64);
                    web.Update();
                    Console.ReadKey();
                }
            }

            //byte[] sidBytes = UserPropertiesHelper.ConvertStringSidToSid("S-1-5-21-1343462910-744444023-3288617952-1638");
            //string loginName = PeopleEditor.GetAccountFromSid(sidBytes);
            //Console.WriteLine(loginName);
            //Console.ReadKey();

            //foreach (SPServer server in SPFarm.Local.Servers)
            //{
            //    Console.WriteLine(server.Name + "--" + server.Role);
            //    //Helper.Administration.Server.IsWebFrontEnd(server);
            //}
            //Console.ReadKey();
        }

 public static void BindIdentificationType(RadioButtonList rbList, string texto, string valor)
 {
     try
     {
     if (SPContext.Current != null)
     {
       using(Microsoft.SharePoint.SPWeb web = SPContext.Current.Web)
       {
         BLL.IdentificationTypeBLL bll = new CAFAM.WebPortal.BLL.IdentificationTypeBLL(web);
         DataSet ds = bll.GetIdentificationTypeList();
         BindList(rbList, ds, texto, valor);
       }
     }
     else
     {
       using(SPSite site = new SPSite(SP_SITE)){
         using(Microsoft.SharePoint.SPWeb web = site.OpenWeb())
         {
             BLL.IdentificationTypeBLL bll = new CAFAM.WebPortal.BLL.IdentificationTypeBLL(web);
             DataSet ds = bll.GetIdentificationTypeList();
             BindList(rbList, ds, texto, valor);
         }
       }
     }
     }
     catch (Exception ex)
     {
     throw ex;
     }
 }

        public SharepointList ExportListToObjects(string siteUrl, string listName)
        {
            var list = new SPSite(siteUrl).OpenWeb().Lists[listName];
            var cols = new List<SharepointList.Column>();

            foreach (SPField field in list.Fields)
            {
                if(field.ReadOnlyField) continue;
                cols.Add(new SharepointList.Column()
                         {
                             Name = field.InternalName,
                             Type = field.FieldValueType
                         });
            }

            var rows = new List<SharepointList.Row>();
            foreach (SPListItem item in list.Items)
            {
                var values = new List<object>();
                foreach (SPField field in list.Fields)
                {
                    if (field.ReadOnlyField) continue;
                    values.Add(item[field.InternalName]);
                }
                rows.Add(new SharepointList.Row() { Values = values});
            }

            return new SharepointList() {Columns = cols, Rows = rows};
        }

        /// <summary>
        /// Retrieves a TaxonomyValue corresponding to a term label within a desired term store
        /// </summary>
        /// <param name="site">The current site</param>
        /// <param name="termStoreName">The term store name</param>
        /// <param name="termStoreGroupName">The group name</param>
        /// <param name="termSetName">The term set name</param>
        /// <param name="termLabel">The default label of the term</param>
        /// <returns>The taxonomy value or null if not found</returns>
        public TaxonomyValue GetTaxonomyValueForLabel(SPSite site, string termStoreName, string termStoreGroupName, string termSetName, string termLabel)
        {
            TaxonomySession session = this.taxManager.GetSiteTaxonomyCache(site, termStoreName).TaxonomySession;
            TermStore termStore = session.TermStores[termStoreName];

            return GetTaxonomyValueForLabelInternal(termStore, termStoreGroupName, termSetName, termLabel);
        }

        /// <summary>
        /// Runs the specified command.
        /// </summary>
        /// <param name="command">The command.</param>
        /// <param name="keyValues">The key values.</param>
        /// <param name="output">The output.</param>
        /// <returns></returns>
        public override int Execute(string command, StringDictionary keyValues, out string output)
        {
            output = string.Empty;

            string url = Params["url"].Value.TrimEnd('/');
            bool force = Params["force"].UserTypedIn;
            string backupDir = Params["backupdir"].Value;

            SPList list = null;
            if (Utilities.EnsureAspx(url, false, false) && !Params["listname"].UserTypedIn)
                list = Utilities.GetListFromViewUrl(url);
            else if (Params["listname"].UserTypedIn)
            {
                using (SPSite site = new SPSite(url))
                using (SPWeb web = site.OpenWeb())
                {
                    try
                    {
                        list = web.Lists[Params["listname"].Value];
                    }
                    catch (ArgumentException)
                    {
                        throw new SPException("List not found.");
                    }
                }
            }

            if (list == null)
                throw new SPException("List not found.");

            Common.Lists.DeleteList.Delete(force, backupDir, list);

            return (int)ErrorCodes.NoError;
        }

        /// <summary>
        /// Processes the content type.
        /// </summary>
        /// <param name="site">The site.</param>
        /// <param name="contentTypeName">Name of the content type.</param>
        /// <param name="verbose">if set to <c>true</c> [verbose].</param>
        /// <param name="updateFields">if set to <c>true</c> [update fields].</param>
        /// <param name="removeFields">if set to <c>true</c> [remove fields].</param>
        public static void Execute(SPSite site, string contentTypeName, bool updateFields, bool removeFields)
        {
            try
            {
                Logger.Write("Pushing content type changes to lists for '" + contentTypeName + "'");
                // get the site collection specified
                using (SPWeb rootWeb = site.RootWeb)
                {

                    //Get the source site content type
                    SPContentType sourceCT = rootWeb.AvailableContentTypes[contentTypeName];
                    if (sourceCT == null)
                    {
                        throw new ArgumentException("Unable to find Content Type named \"" + contentTypeName + "\"");
                    }
                    Execute(sourceCT, updateFields, removeFields);
                }
                return;
            }
            catch (Exception ex)
            {
                Logger.WriteException(new System.Management.Automation.ErrorRecord(new SPException("Unhandled error occured.", ex), null, System.Management.Automation.ErrorCategory.NotSpecified, null));
                throw;
            }
            finally
            {
                Logger.Write("Finished pushing content type changes to lists for '" + contentTypeName + "'");
            }
        }

        private SiteMapNode BuildFullMenuStructure(SPWeb currentWeb)
        {
            Clear();

            SiteMapNode root = null;

            SPWeb webSite = SPContext.Current.Site.RootWeb;
            string relativeUrl = webSite.ServerRelativeUrl.ToString();

            SPSecurity.RunWithElevatedPrivileges(delegate()
            {
                SPSite currentsite = new SPSite(webSite.Site.Url);
                SPWeb rootweb = currentsite.OpenWeb(relativeUrl);

                root = new SiteMapNode(this, rootweb.ID.ToString(), rootweb.ServerRelativeUrl, rootweb.Title);

                if (rootweb == currentWeb)
                {
                    SiteMapNode root2 = new SiteMapNode(this, "Root", "/", null);
                    AddNode(root2);

                    string cacheKey = rootweb.ID.ToString();
                    AddMenuToCache(cacheKey, root2);
                }

                foreach (SPWeb web in rootweb.Webs)
                {
                    SiteMapNode node = BuildNodeTree(web);
                    AddNode(node, root);
                }
            });

            return root;
        }

        private void AddFileInfo(SPItemEventProperties properties)
        {
            try
            {
                var url = properties.WebUrl + "/" + properties.AfterUrl;
                var fileName = properties.AfterUrl;

                using (var site = new SPSite(properties.Web.Site.ID))
                using (var web = site.RootWeb)
                {
                    var list = web.Lists[LogList.ListName];
                    var listItems = list.Items;

                    var item = listItems.Add();
                    item["Title"] = fileName;
                    item["URL"] = url;
                    item.Update();
                }

                ULSLog.LogDebug(String.Format("Added {0} to {1} list", url, LogList.ListName));
            }
            catch (Exception ex)
            {
                ULSLog.LogError(ex);
            }
        }

        public static SPList GetSpecifiedList(string listName)
        {
            // get fresh SPSite and SPWeb objects so they run in the correct context
            // depending on whether we have elevated privileges to view draft items
            // or not

            //Not sure if caching a good idea here or not...
            //object cacheData = HttpContext.Current.Cache["ListCache" + listName];

            //if (cacheData != null)
            //    return (SPList)cacheData;

            using (SPSite site = new SPSite(SPContext.Current.Site.ID))
            {
                if (listName.StartsWith("/"))
                {
                //    SPList lst=site.RootWeb.Lists[listName.Substring(1)];
                //    HttpContext.Current.Cache.Add("ListCache" + listName, lst, null, DateTime.Now.AddHours(12), System.Web.Caching.Cache.NoSlidingExpiration,
                //System.Web.Caching.CacheItemPriority.Default, null);
                    return site.RootWeb.Lists[listName.Substring(1)];
                }
                else
                {
                    using (SPWeb web = site.OpenWeb(SPContext.Current.Web.ID))
                    {
                    //    SPList lst = web.Lists[listName];
                    //    HttpContext.Current.Cache.Add("ListCache" + listName, lst, null, DateTime.Now.AddHours(12), System.Web.Caching.Cache.NoSlidingExpiration,
                    //System.Web.Caching.CacheItemPriority.Default, null);

                        return web.Lists[listName];
                    }
                }
            }
        }

        public static DateTime? GetLastUpdateDate()
        {
            DateTime? maxValue = null;

            try
            {
                SPWeb web;
                if (SPContext.Current != null)
                    web = SPContext.Current.Web;
                else
                    web = new SPSite("http://finweb.contoso.com/sites/PMM").OpenWeb();

                SPList objList = web.Lists.TryGetList(Constants.LIST_NAME_PROJECT_TASKS);

                SPQuery objQuery = new SPQuery();
                objQuery.Query = "<OrderBy><FieldRef Name='ModifiedOn' Ascending='False' /></OrderBy><RowLimit>1</RowLimit>";
                objQuery.Folder = objList.RootFolder;

                // Execute the query against the list
                SPListItemCollection colItems = objList.GetItems(objQuery);

                if (colItems.Count > 0)
                {
                    maxValue = Convert.ToDateTime(colItems[0]["ModifiedOn"]);
                }
            }
            catch (Exception ex)
            {

            }

            return maxValue;
        }

        internal static void Guardar(Contacto _contacto)
        {
            String webUrl = "http://sharepointser";

            SPSecurity.RunWithElevatedPrivileges(delegate()
            {
                using (var site = new SPSite(webUrl))
                {
                    using (var web = site.OpenWeb())
                    {
                        SPListItemCollection list = web.Lists["Contactos"].Items;

                        SPListItem item = list.Add();
                        item["Title"] = _contacto.Nombre;
                        item["Identificacion"] = _contacto.Identificacion;

                        var allowUnsafeUpdates = web.AllowUnsafeUpdates;
                        web.AllowUnsafeUpdates = true;

                        item.Update();

                        web.AllowUnsafeUpdates = allowUnsafeUpdates;
                    }
                }
            });
        }

        public void DeployIntranet(SPSite site, Options options)
        {
            // pushing site model
            if (options.DeploySite)
            {
                var siteModel = new IntrSiteModel();

                this.DeploySiteModel(site, siteModel.GetSandboxSolutionsModel());
                this.DeploySiteModel(site, siteModel.GetSiteFeaturesModel());
                this.DeploySiteModel(site, siteModel.GetSiteSecurityModel());
                this.DeploySiteModel(site, siteModel.GetFieldsAndContentTypesModel());
            }

            // pushing root web model
            if (options.DeployRootWeb)
            {
                var rootWebModel = new IntrRootWebModel();

                this.DeployWebModel(site.RootWeb, rootWebModel.GetStyleLibraryModel());
                this.DeployWebModel(site.RootWeb, rootWebModel.GetModel());
            }

            // pushing 'How-tow' sub web
            if (options.DeployHowTosWeb)
            {
                var howTosWebModel = new IntrHowTosWebModel();

                this.DeployWebModel(site.RootWeb, howTosWebModel.GetModel());
            }
        }

        public string createNewDocumentLibrary(SPSite site, string _web, string docLib)
        {
            //foreach (webs web_ in Enum.GetValues(typeof(webs)))
            //{
            try
            {
                bool webExist = webExists(site, _web);

                if (webExist == true)
                {

                    using (SPWeb web = site.OpenWeb(_web))
                    {
                        SPList list = web.Lists.TryGetList(docLib);
                        if (list == null)
                        {
                            SPListTemplateType tempType = SPListTemplateType.DocumentLibrary;
                            web.Lists.Add(docLib, null, tempType);
                            return docLib;
                        }
                    }
                }
                //}
            }
            catch { }
            return docLib;
        }

        /*SP.GlobalTopMenu*/
        /// <summary>
        /// Builds the xDocument of the specific color and Fiscal Year.
        /// </summary>
        /// <param name="strFiscalYearTitle">Fiscal Year title from the Fiscal Year Custom list.</param>
        /// <param name="strColorTitle">Color title from the Color custom list.</param>
        /// <returns></returns>
        public static XDocument GetXDocument(XMLType eXMLName)
        {
            try
            {
                using (SPSite oSite = new SPSite(SiteRootUrl))
                {
                    using (SPWeb oWeb = oSite.OpenWeb())
                    {
                        SPFolder oTargetFolder = oWeb.Folders[XML_LIBRARY];
                        SPFile spFile;

                        if (oWeb.GetFolder(oTargetFolder.Url + "/" + XML_FOLDER).Exists)
                        {
                            if (oWeb.GetFile(oTargetFolder.SubFolders[XML_FOLDER].Url + "/" + eXMLName + ".xml").Exists)
                            {
                                spFile = oTargetFolder.SubFolders[XML_FOLDER].Files[eXMLName + ".xml"];

                                StreamReader sr = new StreamReader(spFile.OpenBinaryStream());

                                return XDocument.Parse(sr.ReadToEnd());
                            }
                        }
                        return emptyXMLFile(eXMLName);
                    }
                }
            }
            catch (Exception ex)
            {
                return emptyXMLFile(eXMLName);
            }
        }

        internal Employee GetEmployeedetails(string name)
        {
            var empEntity = new Employee();
            using (var site = new SPSite(SPContext.Current.Site.Url))
            {
                using (var web = site.OpenWeb())
                {
                    SPUser user = web.CurrentUser;

                    hdnCurrentUsername.Value = user.Name;

                    SPListItemCollection currentUserDetails = GetListItemCollection(web.Lists[Utilities.EmployeeScreen], "Employee Name", name, "Status", "Active");
                    foreach (SPListItem currentUserDetail in currentUserDetails)
                    {
                        empEntity.EmpId = currentUserDetail[Utilities.EmployeeId].ToString();
                        empEntity.EmployeeType = currentUserDetail[Utilities.EmployeeType].ToString();
                        empEntity.Department = currentUserDetail[Utilities.Department].ToString();
                        empEntity.Desigination = currentUserDetail[Utilities.Designation].ToString();
                        empEntity.DOJ = DateTime.Parse(currentUserDetail[Utilities.DateofJoin].ToString());
                        empEntity.ManagerWithID = currentUserDetail[Utilities.Manager].ToString();
                        var spv = new SPFieldLookupValue(currentUserDetail[Utilities.Manager].ToString());
                        empEntity.Manager = spv.LookupValue;
                    }
                }
            }
            return empEntity;
        }

        /// <summary>
        /// Executes the specified command.
        /// </summary>
        /// <param name="command">The command.</param>
        /// <param name="keyValues">The key values.</param>
        /// <param name="output">The output.</param>
        /// <returns></returns>
        public override int Execute(string command, StringDictionary keyValues, out string output)
        {
            output = string.Empty;

            #if !MOSS
            output = NOT_VALID_FOR_FOUNDATION;
            return (int)ErrorCodes.GeneralError;
            #endif

            SPServiceContext context = null;
            if (Params["serviceappname"].UserTypedIn)
            {
                SPSiteSubscriptionIdentifier subId = Utilities.GetSiteSubscriptionId(new Guid(Params["sitesubscriptionid"].Value));
                SPServiceApplication svcApp = Utilities.GetUserProfileServiceApplication(Params["serviceappname"].Value);
                Utilities.GetServiceContext(svcApp, subId);
            }
            else
            {
                using (SPSite site = new SPSite(Params["contextsite"].Value))
                    context = SPServiceContext.GetContext(site);
            }

            Common.Audiences.DeleteAudience.Delete(context,
                   Params["name"].Value,
                   Params["rulesonly"].UserTypedIn);

            return (int)ErrorCodes.NoError;
        }

        protected void btnSave_Click(object sender, EventArgs e)
        {
            foreach (GridViewRow itemRow in this.Gridview1.Rows)
            {
                TextBox txtCount = itemRow.FindControl("txtCounty") as TextBox;
                TextBox txtCountry = itemRow.FindControl("txtCountry") as TextBox;
                TextBox txtDate = itemRow.FindControl("txtDate") as TextBox;

                using (SPSite site = new SPSite(SPContext.Current.Site.Url))
                {
                    using (SPWeb web = site.OpenWeb())
                    {
                        SPList list = web.Lists.TryGetList(Consts.Lists.ScheduleHoliday.ListName);
                        if (list == null) continue;

                        SPListItem itemAdd = list.AddItem();
                        itemAdd[Consts.Lists.ScheduleHoliday.Fields.Title] = txtCount.Text;
                        itemAdd[Consts.Lists.ScheduleHoliday.Fields.Country] = txtCountry.Text;
                        itemAdd[Consts.Lists.ScheduleHoliday.Fields.Holidays] = Convert.ToDateTime(txtDate.Text);
                        itemAdd.Update();
                    }
                }
            }

            SetInitialRow();
        }