/// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        /// <param name="apiContext"></param>
        /// <param name="product_Service_Categories"></param>
        /// <param name="result"></param>
        public static void ValidateData(Helpers.ApiContext apiContext, Entities.Product_Service_Categories product_Service_Categories, ref Helpers.ActionResult result)
        {
            OnValidating(apiContext, product_Service_Categories, ref result);

            if (product_Service_Categories.Id == null)
            {
                result.Messages.Add(Helpers.ActionResultMessage.Factory(product_Service_Categories, "Id is required.", Helpers.ActionResultMessageType.Error));
                result.WasSuccessful = false;
            }

            if (System.String.IsNullOrWhiteSpace(product_Service_Categories.CategoryTitle))
            {
                result.Messages.Add(Helpers.ActionResultMessage.Factory(product_Service_Categories, "CategoryTitle is required.", Helpers.ActionResultMessageType.Error));
                result.WasSuccessful = false;
            }

            if (!System.String.IsNullOrWhiteSpace(product_Service_Categories.CategoryTitle) && product_Service_Categories.CategoryTitle.Length > 50)
            {
                result.Messages.Add(Helpers.ActionResultMessage.Factory(product_Service_Categories, "CategoryTitle must be 50 characters or less.", Helpers.ActionResultMessageType.Error));
                result.WasSuccessful = false;
            }
            if (!System.String.IsNullOrWhiteSpace(product_Service_Categories.CategoryTitle) && !System.Text.RegularExpressions.Regex.IsMatch(product_Service_Categories.CategoryTitle, alphaNumeric))
            {
                result.Messages.Add(Helpers.ActionResultMessage.Factory(product_Service_Categories, "CategoryTitle contains invalid characters.", Helpers.ActionResultMessageType.Error));
                result.WasSuccessful = false;
            }

            OnValidated(apiContext, product_Service_Categories, ref result);
        }
Beispiel #2
0
        private void FixupProduct_Service_Categories(Product_Service_Categories previousValue)
        {
            if (previousValue != null && previousValue.Product_Service_SubCategories.Contains(this))
            {
                previousValue.Product_Service_SubCategories.Remove(this);
            }

            if (Product_Service_Categories != null)
            {
                if (!Product_Service_Categories.Product_Service_SubCategories.Contains(this))
                {
                    Product_Service_Categories.Product_Service_SubCategories.Add(this);
                }
                if (CategoryId != Product_Service_Categories.Id)
                {
                    CategoryId = Product_Service_Categories.Id;
                }
            }
            else if (!_settingFK)
            {
                /* [NOTE] --
                 * I have commented following, as in case of detaching entities from ObjectState it was making EntityId Null into referenced entities,
                 * which is not desired behavior for us.
                 */
                //CategoryId = null;
            }
        }
        /// <summary>
        ///		No Metadata Documentation available.
        /// </summary>
        /// <param name="apiContext"></param>
        /// <param name="id"></param>
        /// <param name="product_Service_Categories"></param>
        /// <returns></returns>
        public static Helpers.ActionResult Get(Helpers.ApiContext apiContext, int id, out Entities.Product_Service_Categories product_Service_Categories)
        {
            // API doesn't allow null parameters.
            if (apiContext == null)
            {
                throw new System.ArgumentNullException("apiContext");
            }
            if (id == null)
            {
                throw new System.ArgumentNullException("id");
            }

            // Verify user is authorized to perform action, otherwise throw exception.
            Security.SecurityHandler.SetApiContext(apiContext);
            Helpers.ActionResult result = Helpers.ActionResult.Factory(true);

            try
            {
                Model.OrmsContext context = (Model.OrmsContext)apiContext.CurrentContext;
                var qry = context.Product_Service_Categories.Where(r => r.Id.Equals(id)).FirstOrDefault();

                // See what would be default value in this case
                // Also to see if no value found what shall be put into Action Result
                if (qry != null)
                {
                    product_Service_Categories = qry;

                    // must detach the object before return
                    DetachObject(apiContext, product_Service_Categories);
                }
                else
                {
                    product_Service_Categories    = new Entities.Product_Service_Categories();
                    product_Service_Categories.Id = id;

                    result.WasSuccessful = false;
                    result.Messages.Add(Helpers.ActionResultMessage.Factory(product_Service_Categories, "Object not Found", Helpers.ActionResultMessageType.Warning));
                }
            }
            catch (System.Exception ex)
            {
                object forDebugging = ex;
                throw;    // Helpers.Exceptions.GetEntityException.Factory(ex);
            }

            return(result);
        }
        public static Helpers.ActionResult Add(Helpers.ApiContext apiContext, Entities.Product_Service_Categories product_Service_Categories, out long id)
        {
            // API doesn't allow null parameters. This method requires at least 1 item in the collection.
            if (apiContext == null)
            {
                throw new System.ArgumentNullException("apiContext");
            }
            if (product_Service_Categories == null)
            {
                throw new System.ArgumentNullException("image");
            }

            // Verify user is authorized to perform action, otherwise throw exception.
            Security.SecurityHandler.SetApiContext(apiContext);

            Helpers.ActionResult result = Helpers.ActionResult.Factory(true);

            try
            {
                Model.OrmsContext context = (Model.OrmsContext)apiContext.CurrentContext;

                // ADD to context
                OnAdding(apiContext, product_Service_Categories);

                context.AddObject("Product_Service_Categories", product_Service_Categories);

                context.SaveChanges();                 // Save Changes

                id = product_Service_Categories.Id;

                DetachObjects(apiContext, new System.Collections.Generic.List <Entities.Product_Service_Categories> {
                    product_Service_Categories
                });                                                                                                                                                // Clean ObjectState cache
            }
            catch (System.Exception ex)
            {
                object forDebugging = ex;
                throw;                // Helpers.Exceptions.AddEntityException.Factory(ex);
            }

            return(result);
        }
        /// <summary>
        /// No Metadata Documentation available.
        /// </summary>
        /// <param name="apiContext"></param>
        /// <param name="whereClause"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static bool IsExists(Helpers.ApiContext apiContext, System.Linq.Expressions.Expression <System.Func <Entities.Product_Service_Categories, bool> > whereClause, out Entities.Product_Service_Categories entity)
        {
            // API doesn't allow null parameters. This method requires at least 1 item in the collection.
            if (apiContext == null)
            {
                throw new System.ArgumentNullException("apiContext");
            }
            if (whereClause == null)
            {
                throw new System.ArgumentNullException("whereClause");
            }

            // Verify user is authorized to perform action, otherwise throw exception.
            Security.SecurityHandler.SetApiContext(apiContext);
            try
            {
                Model.OrmsContext context = (Model.OrmsContext)apiContext.CurrentContext;
                var query = context.Product_Service_Categories.Where(whereClause).FirstOrDefault();

                if (query != null)
                {
                    entity = query;
                    DetachObject(apiContext, entity);     // must detach the object before return
                }
                else
                {
                    entity = null;
                }

                return(query != null);
            }
            catch (System.Exception ex)
            {
                object forDebugging = ex;
                throw;    // Helpers.Exceptions.ExistsException.Factory(ex);
            }
        }
 //	This partial method gives us a way to access an object after it has been purged from the system.
 static partial void OnPurged(Helpers.ApiContext apiContext, Entities.Product_Service_Categories product_Service_Categories);
 //	This partial method gives us a way to access an object after it has been validated in the system.
 static partial void OnValidated(Helpers.ApiContext apiContext, Entities.Product_Service_Categories product_Service_Categories, ref Helpers.ActionResult result);
 //	This partial method gives us a way to access an object after it has been updated in the system.
 static partial void OnUpdated(Helpers.ApiContext apiContext, Entities.Product_Service_Categories product_Service_Categories, bool isBulkUpdate);