C# OrganizationService.Update方法代码示例

        private void UpdateAccount(Guid id, double rating)
        {
            var account = new Entity("account") { Id = id };
            account["test9_yelprating"] = rating;

            CrmConnection connection = CrmConnection.Parse(_connection);
            using (_orgService = new OrganizationService(connection))
            {
                _orgService.Update(account);
            }
        }

        private bool UpdateCrmAssembly(AssemblyItem assemblyItem, CrmConnection connection)
        {
            _dte.StatusBar.Animate(true, vsStatusAnimation.vsStatusAnimationDeploy);

            try
            {
                string outputFileName = _selectedProject.Properties.Item("OutputFileName").Value.ToString();
                string path = GetOutputPath() + outputFileName;

                //Build the project
                SolutionBuild solutionBuild = _dte.Solution.SolutionBuild;
                solutionBuild.BuildProject(_dte.Solution.SolutionBuild.ActiveConfiguration.Name, _selectedProject.UniqueName, true);

                if (solutionBuild.LastBuildInfo > 0)
                    return false;

                //Make sure Major and Minor versions match
                Version assemblyVersion = Version.Parse(_selectedProject.Properties.Item("AssemblyVersion").Value.ToString());
                if (assemblyItem.Version.Major != assemblyVersion.Major ||
                    assemblyItem.Version.Minor != assemblyVersion.Minor)
                {
                    _logger.WriteToOutputWindow("Error Updating Assembly In CRM: Changes To Major & Minor Versions Require Redeployment", Logger.MessageType.Error);
                    return false;
                }

                //Make sure assembly names match
                string assemblyName = _selectedProject.Properties.Item("AssemblyName").Value.ToString();
                if (assemblyName.ToUpper() != assemblyItem.Name.ToUpper())
                {
                    _logger.WriteToOutputWindow("Error Updating Assembly In CRM: Changes To Assembly Name Require Redeployment", Logger.MessageType.Error);
                    return false;
                }

                //Update CRM
                using (OrganizationService orgService = new OrganizationService(connection))
                {
                    Entity crmAssembly = new Entity("pluginassembly") { Id = assemblyItem.AssemblyId };
                    crmAssembly["content"] = Convert.ToBase64String(File.ReadAllBytes(path));

                    orgService.Update(crmAssembly);
                }

                //Update assembly name and version numbers
                assemblyItem.Version = assemblyVersion;
                assemblyItem.Name = _selectedProject.Properties.Item("AssemblyName").Value.ToString();
                assemblyItem.DisplayName = assemblyItem.Name + " (" + assemblyVersion + ")";
                assemblyItem.DisplayName += (assemblyItem.IsWorkflowActivity) ? " [Workflow]" : " [Plug-in]";

                return true;
            }
            catch (FaultException<OrganizationServiceFault> crmEx)
            {
                _logger.WriteToOutputWindow("Error Updating Assembly In CRM: " + crmEx.Message + Environment.NewLine + crmEx.StackTrace, Logger.MessageType.Error);
                return false;
            }
            catch (Exception ex)
            {
                _logger.WriteToOutputWindow("Error Updating Assembly In CRM: " + ex.Message + Environment.NewLine + ex.StackTrace, Logger.MessageType.Error);
                return false;
            }
            finally
            {
                _dte.StatusBar.Clear();
                _dte.StatusBar.Animate(false, vsStatusAnimation.vsStatusAnimationDeploy);
            }
        }

        /// <summary>
        /// The Run() method first connects to the organization service. Afterwards,
        /// basic create, retrieve, update, and delete entity operations are performed.
        /// </summary>
        /// <param name="connectionString">Provides service connection information.</param>
        /// <param name="promptforDelete">When True, the user will be prompted to delete all
        /// created entities.</param>
        public void Run(String connectionString, bool promptforDelete)
        {
            try
            {
                // Establish a connection to the organization web service.
                Print("Connecting to the server ...");
                Microsoft.Xrm.Client.CrmConnection connection = CrmConnection.Parse(connectionString);

                // Obtain an organization service proxy.
                // The using statement assures that the service proxy will be properly disposed.
                using (_orgService = new OrganizationService(connection))
                {
                    Print("connected");
                    Print("Authenticating the user ...");

                    // Create any entity records this sample requires.
                    CreateRequiredRecords();

                    // Obtain information about the logged on user from the web service.
                    Guid userid = ((WhoAmIResponse)_orgService.Execute(new WhoAmIRequest())).UserId;
                    SystemUser systemUser = (SystemUser)_orgService.Retrieve("systemuser", userid,
                        new ColumnSet(new string[] { "firstname", "lastname" }));
                    Println("Logged on user is " + systemUser.FirstName + " " + systemUser.LastName + ".");

                    // Retrieve the version of Microsoft Dynamics CRM.
                    RetrieveVersionRequest versionRequest = new RetrieveVersionRequest();
                    RetrieveVersionResponse versionResponse =
                        (RetrieveVersionResponse)_orgService.Execute(versionRequest);
                    Println("Microsoft Dynamics CRM version " + versionResponse.Version + ".");

                    // Instantiate an account object. Note the use of option set enumerations defined in OptionSets.cs.
                    // Refer to the Entity Metadata topic in the SDK documentation to determine which attributes must
                    // be set for each entity.
                    Account account = new Account { Name = "Fourth Coffee" };
                    account.AccountCategoryCode = new OptionSetValue((int)AccountAccountCategoryCode.PreferredCustomer);
                    account.CustomerTypeCode = new OptionSetValue((int)AccountCustomerTypeCode.Investor);

                    // Create an account record named Fourth Coffee.
                    _accountId = _orgService.Create(account);

                    Println(account.LogicalName + " " + account.Name + " created, ");

                    // Retrieve several attributes from the new account.
                    ColumnSet cols = new ColumnSet(
                        new String[] { "name", "address1_postalcode", "lastusedincampaign" });

                    Account retrievedAccount = (Account)_orgService.Retrieve("account", _accountId, cols);
                    Print("retrieved, ");

                    // Update the postal code attribute.
                    retrievedAccount.Address1_PostalCode = "98052";

                    // The address 2 postal code was set accidentally, so set it to null.
                    retrievedAccount.Address2_PostalCode = null;

                    // Shows use of a Money value.
                    retrievedAccount.Revenue = new Money(5000000);

                    // Shows use of a Boolean value.
                    retrievedAccount.CreditOnHold = false;

                    // Update the account record.
                    _orgService.Update(retrievedAccount);
                    Print("and updated.");

                    // Delete any entity records this sample created.
                    DeleteRequiredRecords(promptforDelete);
                }
            }

            // Catch any service fault exceptions that Microsoft Dynamics CRM throws.
            catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
            {
                // You can handle an exception here or pass it back to the calling method.
                throw;
            }
        }

        /// <summary>
        /// runs the import process
        /// </summary>
        public void Process()
        {
            logger = LogManager.GetLogger(typeof(Importer));
            LogMessage("INFO", "starting job");
            ParseConnections();

            SetupGuidMappings();

            LogMessage("INFO","processing records");
            OrganizationService sourceService = new OrganizationService(_sourceConn);
            OrganizationService targetService = new OrganizationService(_targetConn);

            foreach (var item in JobSteps)
            {
                JobStep step = (JobStep)item;
                LogMessage("INFO",string.Format("starting step {0}", step.StepName));
                string fetchQuery = step.StepFetch;

                LogMessage("INFO","  retrieving records");

                // Set the number of records per page to retrieve.
                int fetchCount = 5000;
                
                // Initialize the page number.
                int pageNumber = 1;

                // Specify the current paging cookie. For retrieving the first page, 
                // pagingCookie should be null.
                string pagingCookie = null;

                //create a list of entities to hold retrieved entities so we can page through results
                List<Entity> ec = new List<Entity>();

                while (true)
                {
                    // Build fetchXml string with the placeholders.
                    string fetchXml = CreateXml(fetchQuery, pagingCookie, pageNumber, fetchCount);

                    EntityCollection retrieved = sourceService.RetrieveMultiple(new FetchExpression(fetchXml));
                    ec.AddRange(retrieved.Entities);

                    if (retrieved.MoreRecords)
                    {
                        // Increment the page number to retrieve the next page.
                        pageNumber++;

                        // Set the paging cookie to the paging cookie returned from current results.                            
                        pagingCookie = retrieved.PagingCookie;
                    }
                    else
                    {
                        // If no more records in the result nodes, exit the loop.
                        break;
                    }
                }

                LogMessage("INFO",string.Format("  {0} records retrieved", ec.Count));
                if (ec.Count > 0)
                {
                    foreach (Entity entity in ec)
                    {
                        //create a list to hold the replacement guids. a second pass is required because c# disallows modifying a collection while enumerating
                        List<KeyValuePair<string, object>> guidsToUpdate = new List<KeyValuePair<string, object>>();
                        LogMessage("INFO",string.Format("  processing record {0}, {1}", entity.Id, entity.LogicalName));
                        try
                        {
                            LogMessage("INFO","    processing GUID replacements");
                            foreach (KeyValuePair<string, object> attribute in entity.Attributes)
                            {
                                //LogMessage("INFO",string.Format("Attribute - {0} {1}", attribute.Key, attribute.Value.GetType().ToString()));
                                if (attribute.Value is Microsoft.Xrm.Sdk.EntityReference)
                                {
                                    //LogMessage("INFO","getting source");

                                    EntityReference source = ((EntityReference)attribute.Value);
                                    try
                                    {
                                        //LogMessage("INFO","looking for GUID replacement");
                                        Guid sourceId = source.Id;
                                        Guid targetId = _mappings.Find(t => t.sourceId == source.Id).targetId;
                                        source.Id = targetId;
                                        guidsToUpdate.Add(new KeyValuePair<string, object>(attribute.Key, source));
                                        //LogMessage("INFO",string.Format("replacement found - {0} -> {1}", sourceId, targetId));
                                    }
                                    catch (System.NullReferenceException ex)
                                    {
                                        //LogMessage("INFO", "NullReferenceException happened");
                                        //do nothing because nullreferenceexception means there's no guid mapping to use
                                    }
                                }
                            }

                            //now actually update the GUIDs with the mapped values
                            foreach (KeyValuePair<string, object> attribute in guidsToUpdate)
                            {
                                //LogMessage("INFO",string.Format("    replacing attribute GUID {0} {1}", attribute.Key, attribute.Value));
                                entity[attribute.Key] = attribute.Value;
//.........这里部分代码省略.........

        public void UpdateAssignedPerson(ServiceRequest serviceRequest)
        {
            var idOfUpdatedItem = serviceRequest.SRID;

            var connection = ConnectToDatabase();
            var service = new OrganizationService(connection);
            var context = new CrmOrganizationServiceContext(connection);

            Guid consultantID = findConsultantID(serviceRequest.AssignedPerson, service);
            ColumnSet set = new ColumnSet();
            set.AllColumns = true;

            //Gather the components for the "Retrieve" function
            Guid incidentGuid = GetGUIDByName(idOfUpdatedItem, service);

            //Retrieves the record that will be updated
            var incident = service.Retrieve("incident", incidentGuid, set);
            EventLog.saveMessage("Updating the consultant person of case: " + serviceRequest.SRID + "to " + serviceRequest.AssignedPerson);
            try
            {
                //Assign a case!
                AssignRequest assignRequest = new AssignRequest();
                assignRequest.Assignee = new EntityReference("systemuser", consultantID);
                assignRequest.Target = new EntityReference(incident.LogicalName, incidentGuid);

                //sets the new User.
                //incident["ownerid"] = new EntityReference("systemuser", consultantID);
               
                service.Update(incident);
                service.Execute(assignRequest);

            }
            catch (Exception)
            {
                EventLog.saveMessage("Updating the consultant person of case: " + serviceRequest.SRID + "to " + serviceRequest.AssignedPerson + " failed!");

                return;
            }
        }

        public void UpdateStatus(ServiceRequest serviceRequest)
        {
            var idOfUpdatedItem = serviceRequest.SRID;

            //Login and connect to the server and create the context
            var connection = ConnectToDatabase();
            var service = new OrganizationService(connection);
            var context = new CrmOrganizationServiceContext(connection);

            //Gather the components for the "Retrieve" function
            ColumnSet set = new ColumnSet();
            set.AllColumns = true;
            Guid incidentGuid = GetGUIDByName(idOfUpdatedItem, service);

            //Retrieves the record that will be updated
            var incident = service.Retrieve("incident", incidentGuid, set);

            EventLog.saveMessage("Update Status of SRID:" + serviceRequest.SRID);

            try
            {
                // Actual UPDATE of the record.

                incident["description"] = serviceRequest.LongDescription;
                incident["statuscode"] = ReturnStatusCode(serviceRequest.ServiceRequestStatus);
                incident["subjectid"] = ReturnRequestType(serviceRequest.ServiceRequestType);
                incident["new_moduleoptionset"] = ReturnModuleCode("TS");
                //incident["ownerid"] = new EntityReference("systemuser", findConsultantID(serviceRequest.AssignedPerson,service));
                incident["new_statushistory"] = serviceRequest.CommentsMatricia;
                incident["casetypecode"] = returnRequestKind(serviceRequest.ServiceRequestKind);
                incident["new_caseasignedto"] = serviceRequest.AssignedPerson;
                //incident["followupby"] = serviceRequest.DueDate;
                incident["title"] = serviceRequest.AssignedToClient + " " + serviceRequest.SRID + " " + serviceRequest.companyName;
                //incident["customerid"] = new EntityReference("account", findCustomer((string)serviceRequest.companyName, service));
                incident["customerid"] = new EntityReference("account", findCustomerID(serviceRequest.companyName));
                incident["new_statushistory"] = serviceRequest.ShortDescription;
                incident["new_assignedfrom"] = serviceRequest.CreatedBy;

                Guid consultantID = findConsultantID(serviceRequest.AssignedPerson, service);

                //Assign a case!
               

                service.Update(incident);

                EventLog.saveMessage("Start of Assignment! to :" + consultantID);
                AssignRequest assignRequest = new AssignRequest();
                assignRequest.Assignee = new EntityReference("systemuser", consultantID);
                assignRequest.Target = new EntityReference(incident.LogicalName, incidentGuid);
                service.Execute(assignRequest);

            }
            catch (Exception)
            {
                EventLog.saveMessage("This record is unavailable for update right now!" + serviceRequest.SRID);
                return;
            }

        }

    //receieves user data in the form of a MembershipUser type
    //overides any existing data with data in user
    public override void UpdateUser(MembershipUser user)
    {
        //TC
        using (OrganizationService service = new OrganizationService(OurConnect()))
        {
            ConditionExpression guidCondition = new ConditionExpression();
            ConditionExpression deleteCondition = new ConditionExpression();
            ConditionExpression appCondition = new ConditionExpression();

            guidCondition.AttributeName = consts.accountid;
            guidCondition.Operator = ConditionOperator.Equal;
            guidCondition.Values.Add(user.ProviderUserKey);

            deleteCondition.AttributeName = consts.deleteduser;
            deleteCondition.Operator = ConditionOperator.Equal;
            deleteCondition.Values.Add(false);

            appCondition.AttributeName = consts.appname;
            appCondition.Operator = ConditionOperator.Equal;
            appCondition.Values.Add(_ApplicationName);

            FilterExpression filter = new FilterExpression();
            filter.Conditions.Add(guidCondition);
            filter.Conditions.Add(deleteCondition);
            filter.Conditions.Add(appCondition);

            QueryExpression query = new QueryExpression(consts.useraccount);
            query.ColumnSet.AllColumns = true;
            query.Criteria.AddFilter(filter);

            EntityCollection collection = service.RetrieveMultiple(query);

            if (collection.Entities.Count == 0)
            {
                return;
            }

            collection.Entities[0][consts.username] = user.UserName;
            collection.Entities[0][consts.securityquestion] = user.PasswordQuestion;
            collection.Entities[0][consts.email] = user.Email;
            collection.Entities[0][consts.lockn] = user.IsLockedOut;

            service.Update(collection.Entities[0]);
            activity(user.UserName, "", true);

            return;
        }
    }

        static void Main(string[] args)
        {
            Console.WriteLine("Enter the source connection string: ");
            sourceOrg = Console.ReadLine();
            try
            {
                sourceConn = CrmConnection.Parse(sourceOrg);
            }
            catch(Exception ex)
            {
                Console.WriteLine("Could not parse source connection string: {0}", ex.Message);
                return;
            }

            Console.WriteLine("Enter the destination connection string: ");
            targetOrg = Console.ReadLine();
            try
            {
                targetConn = CrmConnection.Parse(targetOrg);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Could not parse destination connection string: {0}", ex.Message);
                return;
            }

            //export teamtemplates
            using (OrganizationService service = new OrganizationService(sourceConn))
            {
                try
                {
                    //attributes to exclude from the query
                    List<string> IgnoredAttributes = new List<string> { "issystem" };

                    Console.WriteLine("Retrieving entity metadata . . .");
                    RetrieveEntityRequest entityreq = new RetrieveEntityRequest
                    {
                        LogicalName = "teamtemplate",
                        EntityFilters = Microsoft.Xrm.Sdk.Metadata.EntityFilters.Attributes
                    };
                    RetrieveEntityResponse entityres = (RetrieveEntityResponse)service.Execute(entityreq);
                    string fetchXml = "<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>";
                    fetchXml += "<entity name='teamtemplate'>";

                    foreach (AttributeMetadata amd in entityres.EntityMetadata.Attributes)
                    {
                        if (!IgnoredAttributes.Contains(amd.LogicalName))
                        {
                            fetchXml += "<attribute name='" + amd.LogicalName + "' />";
                            //Console.WriteLine(amd.LogicalName);
                        }
                    }
                    fetchXml += "</entity></fetch>";

                    Console.WriteLine("");
                    Console.WriteLine("Exporting data . . .");
                    exported = service.RetrieveMultiple(new FetchExpression(fetchXml));
                }
                catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault> ex)
                {
                    Console.WriteLine("Could not export data: {0}", ex.Message);
                    return;
                }
            }

            //import teamtemplates
            Console.WriteLine("Importing data . . .");
            using (OrganizationService service = new OrganizationService(targetConn))
            {
                if (exported.Entities.Count > 0)
                {
                    foreach (Entity entity in exported.Entities)
                    {
                        try
                        {
                            //Console.WriteLine("Id - {0}", entity.Id.ToString());

                            //try to update first
                            try
                            {
                                service.Update(entity);
                            }
                            catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
                            {
                                //if update fails, then create
                                service.Create(entity);
                            }
                        }
                        catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault> ex)
                        {
                            //if everything fails, return error
                            Console.WriteLine("Error: {0} - {1}", entity.Id, entity["teamtemplatename"]);
                        }
                    }
                }
            }
            Console.WriteLine("Import complete");
            Console.WriteLine("");
            Console.WriteLine("Press the enter key to exit");
            Console.ReadLine();
//.........这里部分代码省略.........

    //recevies a username string
    //returns false if user does not exist or is already unlocked
    //returns true if user was locked, and unlocks the user account
    public override bool UnlockUser(string userName)
    {
        using (OrganizationService service = new OrganizationService(OurConnect()))
        {
            ConditionExpression usernameCondition = new ConditionExpression();
            ConditionExpression deleteCondition = new ConditionExpression();
            ConditionExpression appCondition = new ConditionExpression();

            usernameCondition.AttributeName = consts.username;
            usernameCondition.Operator = ConditionOperator.Equal;
            usernameCondition.Values.Add(userName);

            deleteCondition.AttributeName = consts.deleteduser;
            deleteCondition.Operator = ConditionOperator.Equal;
            deleteCondition.Values.Add(false);

            appCondition.AttributeName = consts.appname;
            appCondition.Operator = ConditionOperator.Equal;
            appCondition.Values.Add(_ApplicationName);

            FilterExpression filter = new FilterExpression();
            filter.Conditions.Add(usernameCondition);
            filter.Conditions.Add(deleteCondition);
            filter.Conditions.Add(appCondition);

            QueryExpression query = new QueryExpression(consts.useraccount);
            query.ColumnSet.AddColumns(consts.lockn);
            query.Criteria.AddFilter(filter);

            EntityCollection collection = service.RetrieveMultiple(query);

            if (collection.Entities.Count == 0 || !(bool)collection.Entities[0][consts.lockn])
            {
                return false; //no user or already unlocked
            }
            else
            {
                collection.Entities[0][consts.lockn] = false;
                service.Update(collection.Entities[0]);
                activity(userName, "Unlocked", true);

                return true;
            }
        }
    }

    //receives the username and security answer strings
    //returns null if the security answer is incorrect
    //returns a reset password string if security answer is correct
    public override string ResetPassword(string username, string answer)
    {
        //bcd
        using (OrganizationService service = new OrganizationService(OurConnect()))
        {
            if (!EnablePasswordReset)
            {
                throw new NotSupportedException("Config file has been set to not allow password reset");
                //return null;
            }
            else
            {//reset password based on assigned regular expresssion
                ConditionExpression usernameCondition = new ConditionExpression();
                ConditionExpression deleteCondition = new ConditionExpression();
                ConditionExpression appCondition = new ConditionExpression();
                ConditionExpression answerCondition = new ConditionExpression();

                usernameCondition.AttributeName = consts.username;
                usernameCondition.Operator = ConditionOperator.Equal;
                usernameCondition.Values.Add(username);

                deleteCondition.AttributeName = consts.deleteduser;
                deleteCondition.Operator = ConditionOperator.Equal;
                deleteCondition.Values.Add(false);

                appCondition.AttributeName = consts.appname;
                appCondition.Operator = ConditionOperator.Equal;
                appCondition.Values.Add(_ApplicationName);

                appCondition.AttributeName = consts.securitypassword;
                appCondition.Operator = ConditionOperator.Equal;
                appCondition.Values.Add(answer); //TODO: (Curt) encrypt

                FilterExpression filter = new FilterExpression();
                filter.Conditions.Add(usernameCondition);
                filter.Conditions.Add(deleteCondition);
                filter.Conditions.Add(appCondition);

                QueryExpression query = new QueryExpression(consts.useraccount);
                query.Criteria.AddFilter(filter);
                EntityCollection collection = service.RetrieveMultiple(query);

                if (collection.Entities.Count == 0)
                {
                    throw new MembershipPasswordException("The user's security answer is incorrect");
                    //return null;
                }
                else
                {
                    string NewPass = Membership.GeneratePassword(_MinRequiredPasswordLength, _MinRequiredNonalphanumericCharacters); //changed to have MinRequireNonalphanumericCharacters (CC)
                    collection.Entities[0][consts.securitypassword] = NewPass; //TODO: (Curt) encrypt
                    service.Update(collection.Entities[0]);
                    activity(username, "Reset Password", true);

                    return NewPass;
                }
            }
        }
    }

    //receives a username string and a "delete all related data" boolean
    //returns false if the user does not exist
    //returns true if user data was deleted(soft delete, hard delete optional)
    public override bool DeleteUser(string username, bool deleteAllRelatedData)
    {
        //tc
        using (OrganizationService service = new OrganizationService(OurConnect()))
        {

            ConditionExpression usernameCondition = new ConditionExpression();
            ConditionExpression deleteCondition = new ConditionExpression();
            ConditionExpression appCondition = new ConditionExpression();

            usernameCondition.AttributeName = consts.username;
            usernameCondition.Operator = ConditionOperator.Equal;
            usernameCondition.Values.Add(username);

            deleteCondition.AttributeName = consts.deleteduser;
            deleteCondition.Operator = ConditionOperator.Equal;
            deleteCondition.Values.Add(false);

            appCondition.AttributeName = consts.appname;
            appCondition.Operator = ConditionOperator.Equal;
            appCondition.Values.Add(_ApplicationName);

            FilterExpression filter = new FilterExpression();
            filter.Conditions.Add(usernameCondition);
            filter.Conditions.Add(appCondition);

            QueryExpression query = new QueryExpression(consts.useraccount);
            query.ColumnSet.AddColumn(consts.username);
            query.ColumnSet.AddColumn(consts.deleteduser);
            query.Criteria.AddFilter(filter);

            EntityCollection collection = service.RetrieveMultiple(query);
            if (collection.Entities.Count == 0)
            {
                return false;
            }
            else
            {
                if (!deleteAllRelatedData)
                {
                    collection.Entities[0][consts.deleteduser] = true;
                    activity(username, "Deleted", true);
                    service.Update(collection.Entities[0]);
                    return true;
                }
                else
                {//hard delete
                    service.Delete(consts.useraccount, collection.Entities[0].Id);
                    return true;
                }
            }
        }
    }

    //CHANGE SECURITY QUESTION AND ANSWER
    //Requires a username, password, a new Password Question, and new Password Answer string
    //Returns a boolean value of true if the username and password match and modifies the password question and answer in the user account
    //Returns false if password is incorrect
    public override bool ChangePasswordQuestionAndAnswer(string username, string password, string newPasswordQuestion, string newPasswordAnswer)
    {
        using (OrganizationService service = new OrganizationService(OurConnect()))
        {
            ConditionExpression usernameCondition = new ConditionExpression();
            ConditionExpression appCondition = new ConditionExpression();
            ConditionExpression deleteCondition = new ConditionExpression();
            ConditionExpression passwordCondition = new ConditionExpression();

            usernameCondition.AttributeName = consts.username;
            usernameCondition.Operator = ConditionOperator.Equal;
            usernameCondition.Values.Add(username);

            appCondition.AttributeName = consts.appname;
            appCondition.Operator = ConditionOperator.Equal;
            appCondition.Values.Add(_ApplicationName);

            deleteCondition.AttributeName = consts.deleteduser;
            deleteCondition.Operator = ConditionOperator.Equal;
            deleteCondition.Values.Add(false);

            passwordCondition.AttributeName = consts.password;
            passwordCondition.Operator = ConditionOperator.Equal;
            passwordCondition.Values.Add(EncryptPassword(StringToAscii(password)));

            FilterExpression filter = new FilterExpression();
            filter.Conditions.Add(usernameCondition);
            filter.Conditions.Add(appCondition);
            filter.Conditions.Add(deleteCondition);
            filter.Conditions.Add(passwordCondition);

            QueryExpression query = new QueryExpression(consts.useraccount);
            query.ColumnSet.AddColumns(consts.securityquestion);
            query.ColumnSet.AddColumns(consts.securitypassword);
            query.Criteria.AddFilter(filter);

            EntityCollection collection = service.RetrieveMultiple(query);

            if (collection.Entities.Count == 0)
            {
                return false;
            }
            else
            {
                collection.Entities[0][consts.securityquestion] = newPasswordQuestion;
                collection.Entities[0][consts.securityanswer] = EncryptPassword(StringToAscii(newPasswordAnswer));

                service.Update(collection.Entities[0]);
                return true;
            }
        }
    }

    //receives username and password strings
    //returns true if password is correct
    //returns false if password is incorrect or user does not exist
    public override bool ValidateUser(string username, string password)
    {
        //bcd
        using (OrganizationService service = new OrganizationService(OurConnect()))
        {
            ConditionExpression usernameCondition = new ConditionExpression();
            ConditionExpression deleteCondition = new ConditionExpression();
            ConditionExpression appCondition = new ConditionExpression();

            usernameCondition.AttributeName = consts.username;
            usernameCondition.Operator = ConditionOperator.Equal;
            usernameCondition.Values.Add(username);

            deleteCondition.AttributeName = consts.deleteduser;
            deleteCondition.Operator = ConditionOperator.Equal;
            deleteCondition.Values.Add(false);

            appCondition.AttributeName = consts.appname;
            appCondition.Operator = ConditionOperator.Equal;
            appCondition.Values.Add(_ApplicationName);

            FilterExpression filter = new FilterExpression();
            filter.Conditions.Add(usernameCondition);
            filter.Conditions.Add(deleteCondition);
            filter.Conditions.Add(appCondition);

            QueryExpression query = new QueryExpression(consts.useraccount);
            query.ColumnSet.AllColumns = true;
            query.Criteria.AddFilter(filter);

            EntityCollection collection = service.RetrieveMultiple(query);

            if (collection.Entities.Count == 0)
                return false;
            if ((bool)collection.Entities[0][consts.lockn])
                return false;

            if (!collection.Entities[0][consts.password].Equals(password)) //TODO: (Curt) encrypt(EncryptPassword(StringToAsci(password))))//user exists, but pass is wrong
            {
                ConditionExpression failedCondition = new ConditionExpression();
                ConditionExpression activitytimeCondition = new ConditionExpression();

                failedCondition.AttributeName = consts.subject;
                failedCondition.Operator = ConditionOperator.Equal;
                failedCondition.Values.Add("Failed Login");

                activitytimeCondition.AttributeName = consts.activitytime;
                activitytimeCondition.Operator = ConditionOperator.OnOrAfter;
                activitytimeCondition.Values.Add(DateTime.Now.AddMinutes((double)(-_PasswordAttemptWindow)));

                FilterExpression filter2 = new FilterExpression();
                filter2.Conditions.Add(failedCondition);
                filter2.Conditions.Add(activitytimeCondition);

                QueryExpression query2 = new QueryExpression(consts.activities);
                query2.ColumnSet.AllColumns = true;
                query2.Criteria.AddFilter(filter2);

                EntityCollection collection2 = service.RetrieveMultiple(query2);

                if(collection2.Entities.Count < _MaxInvalidPasswordAttempts)
                {
                    activity(username, "Failed Login", false);
                    collection.Entities[0][consts.loginattempts] = (int)collection.Entities[0][consts.loginattempts] + 1;
                }
                else if(collection2.Entities.Count ==  _MaxInvalidPasswordAttempts)
                {
                    activity(username, "Locked", true);
                    collection.Entities[0][consts.lockn] = true;
                    collection.Entities[0][consts.loginattempts] = 0;
                }

                service.Update(collection.Entities[0]);//update user information
                return false;
            }
            else
            {
                //reset attributes of login stuff
                collection.Entities[0][consts.online] = true;
                collection.Entities[0][consts.loginattempts] = 0;
                activity(username, "Login", false);

                service.Update(collection.Entities[0]);
                return true;
            }
        }
    }