Example #1
0
        /// <summary>
        /// Runs a query and returns all entities that match the query.
        /// </summary>
        /// <param name="query">The query to execute. Do not specify columns or ordering. Only specify conditions and a root entity (and any joins required to apply the condition).</param>
        /// <param name="request">The description of fields and related entities to load.</param>
        /// <returns>The requested data for all entities matched by the query.</returns>
        public IEnumerable <EntityData> QueryEntityData(StructuredQuery query, EntityMemberRequest request)
        {
            try
            {
                // Validate input
                if (query == null)
                {
                    throw new ArgumentNullException("query");
                }
                if (query.SelectColumns.Count > 0)
                {
                    throw new ArgumentException("query.SelectColumns must be empty", "query");
                }
                request = ValidateRequest(request);

                // Create context
                Context context = new Context();

                // Query for top-level entities
                IEntityRef[]          members  = RequestedMembers(request, context);
                IEnumerable <IEntity> entities = Entity.GetMatches(query, members);

                // Fill data
                IEnumerable <EntityData> result = PackageEntities(context, request, entities, true);

                var list = result.Where(e => e != null).ToList();
                return(list);
            }
            catch (Exception ex)
            {
                string xml = "";
                try { xml = EDC.ReadiNow.Metadata.Query.Structured.StructuredQueryHelper.ToXml(query); }
                catch { }
                EventLog.Application.WriteError("Failed QueryEntityData:\nRequest:\n{0}\n\nQuery:\n{1}\n\nException:\n{2}",
                                                request == null ? "null" : request.Debug(), xml, ex);
                throw;
            }
        }
Example #2
0
        /// <summary>
        /// Reset the specified user account password.
        /// </summary>
        /// <param name="jsonResetPasswordRequest">The password reset details.</param>
        /// <returns></returns>
        private HttpResponseMessage ResetPasswordSoftwarePlatform(JsonResetPasswordRequest jsonResetPasswordRequest)
        {
            string tenant      = jsonResetPasswordRequest.Tenant;
            string newPassword = jsonResetPasswordRequest.NewPassword;

            if (string.IsNullOrEmpty(newPassword))
            {
                return(new HttpResponseMessage <string>("The new password is invalid", HttpStatusCode.BadRequest));
            }

            if (string.IsNullOrEmpty(tenant))
            {
                return(new HttpResponseMessage <string>("The tenant is invalid", HttpStatusCode.BadRequest));
            }

            try
            {
                using (new TenantAdministratorContext(tenant))
                {
                    string key = jsonResetPasswordRequest.Key;

                    // Create query
                    var type = new EntityRef("core", "userAccount");

                    var query = new EDC.ReadiNow.Metadata.Query.Structured.StructuredQuery
                    {
                        RootEntity = new EDC.ReadiNow.Metadata.Query.Structured.ResourceEntity(type)
                    };
                    var passwordResetEntity = new EDC.ReadiNow.Metadata.Query.Structured.RelatedResource(new EntityRef("core:passwordReset"));

                    query.RootEntity.RelatedEntities.Add(passwordResetEntity);

                    query.Conditions.Add(new EDC.ReadiNow.Metadata.Query.Structured.QueryCondition
                    {
                        Expression = new EDC.ReadiNow.Metadata.Query.Structured.ResourceDataColumn(passwordResetEntity, new EntityRef("core:passwordResetKey")),
                        Operator   = EDC.ReadiNow.Metadata.Query.Structured.ConditionType.Equal,
                        Argument   = new EDC.ReadiNow.Metadata.TypedValue(key)
                    });
                    // Get results
                    IEnumerable <UserAccount> entities = ReadiNow.Model.Entity.GetMatches <UserAccount>(query);

                    UserAccount accountInfo = entities != null && entities.Count() > 0 ? entities.FirstOrDefault() : null;

                    if (accountInfo == null || accountInfo.PasswordReset == null)
                    {
                        return(new HttpResponseMessage <string>("This key is invalid, Please contact your administrator.", HttpStatusCode.BadRequest));
                    }

                    if (accountInfo.PasswordReset.PasswordResetExpiry < DateTime.UtcNow)
                    {
                        return(new HttpResponseMessage <string>("This key is expired, Please contact your administrator.", HttpStatusCode.BadRequest));
                    }

                    UserAccount account = accountInfo.AsWritable <UserAccount>();

                    if (account.AccountStatus_Enum == UserAccountStatusEnum_Enumeration.Expired || account.AccountStatus_Enum == UserAccountStatusEnum_Enumeration.Disabled)
                    {
                        return(new HttpResponseMessage <string>("Your account has expired or has been disabled. Please contact your administrator", HttpStatusCode.BadRequest));
                    }

                    if (account == null)
                    {
                        throw new InvalidCredentialException("Invalid account, Please contact your administrator.");
                    }

                    account.Password = newPassword;
                    account.PasswordReset.AsWritable <PasswordResetRecord>();
                    account.PasswordReset.Delete();

                    //unlock the account
                    account.AccountStatus_Enum = UserAccountStatusEnum_Enumeration.Active;
                    try
                    {
                        account.Save();
                    }
                    catch (Exception ex)
                    {
                        EventLog.Application.WriteError("Reset Password: Unhandled internal exception: " + ex.ToString());
                        return(new HttpResponseMessage <string>("There is an error to reset your new password. Please contact your administrator", HttpStatusCode.BadRequest));
                    }
                }
            }
            catch (EntityNotFoundException tenantEx)
            {
                string errorMessage = tenantEx.InnerException != null ? tenantEx.InnerException.Message : tenantEx.Message;
                EventLog.Application.WriteError("Reset Password: Unhandled internal Entity Not Found Exception: " + errorMessage);
                return(new HttpResponseMessage <string>(errorMessage, HttpStatusCode.BadRequest));
            }
            catch (Exception otherEx)
            {
                EventLog.Application.WriteError("Reset Password: Unhandled internal Exception: " + otherEx.Message);
                return(new HttpResponseMessage <string>(otherEx.Message, HttpStatusCode.BadRequest));
            }


            return(new HttpResponseMessage(HttpStatusCode.OK));
        }
Example #3
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="jsonPasswordChangeRequest"></param>
        /// <returns></returns>
        private HttpResponseMessage SubmitEmailSoftwarePlatform(JsonSubmitEmailRequest jsonPasswordChangeRequest)
        {
            string tenant = jsonPasswordChangeRequest.Tenant;
            string email  = jsonPasswordChangeRequest.Email;

            if (string.IsNullOrEmpty(email))
            {
                return(new HttpResponseMessage <string>("We can't find a user that links this email address, or the user account has expired or has been disabled. Please contact your administrator.", HttpStatusCode.BadRequest));
            }

            if (string.IsNullOrEmpty(tenant))
            {
                return(new HttpResponseMessage <string>("The tenant is invalid", HttpStatusCode.BadRequest));
            }
            try
            {
                using (new TenantAdministratorContext(tenant))
                {
                    //get account by email


                    // Create query
                    var type = new EntityRef("core", "userAccount");

                    var query = new EDC.ReadiNow.Metadata.Query.Structured.StructuredQuery
                    {
                        RootEntity = new EDC.ReadiNow.Metadata.Query.Structured.ResourceEntity(type)
                    };
                    var accountHolderEntity = new EDC.ReadiNow.Metadata.Query.Structured.RelatedResource(new EntityRef("core:accountHolder"), ReadiNow.Metadata.RelationshipDirection.Reverse);

                    query.RootEntity.RelatedEntities.Add(accountHolderEntity);

                    query.Conditions.Add(new EDC.ReadiNow.Metadata.Query.Structured.QueryCondition
                    {
                        Expression = new EDC.ReadiNow.Metadata.Query.Structured.ResourceDataColumn(accountHolderEntity, new EntityRef("core:name")),
                        Operator   = EDC.ReadiNow.Metadata.Query.Structured.ConditionType.IsNotNull
                    });

                    query.Conditions.Add(new EDC.ReadiNow.Metadata.Query.Structured.QueryCondition
                    {
                        Expression = new EDC.ReadiNow.Metadata.Query.Structured.ResourceDataColumn(accountHolderEntity, new EntityRef("shared:businessEmail")),
                        Operator   = EDC.ReadiNow.Metadata.Query.Structured.ConditionType.Equal,
                        Argument   = new EDC.ReadiNow.Metadata.TypedValue(email)
                    });


                    // Get results
                    IEnumerable <UserAccount> entities = ReadiNow.Model.Entity.GetMatches <UserAccount>(query);

                    if (entities == null || entities.Count() == 0)
                    {
                        return(new HttpResponseMessage <string>("We can't find a user that links this email address, or the user account has expired or has been disabled. Please contact your administrator.", HttpStatusCode.NotFound));
                    }

                    bool success         = false;
                    bool disabledAccount = true;
                    //as required from task 27183, if multiple user accounts are associated with one account holder, then each account will be received email
                    foreach (UserAccount account in entities)
                    {
                        if (account.AccountStatus_Enum != UserAccountStatusEnum_Enumeration.Expired && account.AccountStatus_Enum != UserAccountStatusEnum_Enumeration.Disabled)
                        {
                            success         = SendEmail(account, email, tenant);
                            disabledAccount = false;
                        }
                    }

                    //account.Id
                    if (success == true && disabledAccount == false)
                    {
                        return(new HttpResponseMessage(HttpStatusCode.OK));
                    }
                    else if (disabledAccount == true)
                    {
                        return(new HttpResponseMessage <string>("Your account has expired or has been disabled. Please contact your administrator", HttpStatusCode.BadRequest));
                    }
                    else
                    {
                        return(new HttpResponseMessage <string>("There is an error to send reset password email. Please contact your administrator", HttpStatusCode.BadRequest));
                    }
                }
            }
            catch (EntityNotFoundException tenantEx)
            {
                string errorMessage = tenantEx.InnerException != null ? tenantEx.InnerException.Message : tenantEx.Message;
                EventLog.Application.WriteError("Submit Forget Password Email: Unhandled internal Entity Not Found Exception: " + errorMessage);
                return(new HttpResponseMessage <string>(errorMessage, HttpStatusCode.BadRequest));
            }
            catch (Exception otherEx)
            {
                EventLog.Application.WriteError("Submit Forget Password Email: Unhandled internal Exception: " + otherEx.Message);
                return(new HttpResponseMessage <string>(otherEx.Message, HttpStatusCode.BadRequest));
            }
        }