Currently Im devloping a order page where customer choose the start level and end level, and it would calculate the price because It trigger the "selectindexchange" for the dropdownlist.
The payment method is paypal, which uses the method="post", but whenever I select the level it will just trigger the paypal "buy" button and direct the page to paypal payment page:(
you need to be sure that auto post back property is false for that controls so you require submit button to post it.
Example / Help : autoPostBack
Also use this in page_load
if(!isPostBack){
}
else{
}
which checks the page has load first time or after any post back.
Related
When I create a tag to listen for form submissions using Google Tag Manager.
For my ajax submitted form which does not go to a new page, the submission of a form does not fire the gtm.formSubmit event into the data layer.
What should I do instead?
I need a "codeless" solution to detect form submission and to capture the submitted values.
I ran into another potential reason for this as well and thought I'd drop it in here.
In the Form Submit Listener, you need to have Check Validation unticked for AJAX forms (if the Submit button is blocked from doing a normal submit, as you would do with AJAX forms, this option blocks the listener from firing the correct event).
I have an ajax submitted form and the formSubmit click listener and event tags are working for me.
You might be doing this already, but just to double check;
You are adding 2 tags - the formSubmit listener and the Analytics event tag for that event?
Are you setting up the filters correctly (i.e. including event equals gtm.formSubmit, and the appropriate page?)
If it still isn't working, another suggestion is to use a simple click listener, then filter for both the page the form is on and the id of the submit button.
Here is how Google recommends doing it.
Add a basic page tracking tag (i.e. Tag Type of Google Analytics or Universal Analytics; Track Type of Page View) if you don't already have one. This tag must fire on all pages.
Add a tag of type Event Listener > Form Submit Listener. You can name it “Form Submit Listener”. Add a single firing rule of "All pages", or, for the specific page(s) on which you want to listen for form submissions.
Add a rule (named "Form Submit" for example) with the following condition:
{{event}} equals gtm.formSubmit
Add an Analytics event tracking tag (i.e. Tag Type of Google Analytics or Universal Analytics; Track Type of Event). Add the rule you created in the previous step as the firing rule (for example, "Form Submit"). Enter a Category, Action, and and Label for the event. For example, you might use the following:
Category "Forms"
Action "Submit"
Label "Lead Gen".
Save a version of the container and publish it.
I am using NopCommerce version 3.0. I want the users to get redirected to the login page before they can add products to the cart. I also want to disable the AJAXCart (I want full postback and the products to get added to the cart.).
Please guide me as to how to achieve it.
Thanks.
I have done something similar here: http://clinidirect.co.uk/c-20/continence-care if you add an item to the bag, a popup appears, if you click on "Go to bag" it asks you to login.
This is very rough, but should give you an idea:
First, in _ProductVariantAddToCart.cshtml remove the onclick javascript event from the button, so that the button actually posts the form to AddProductVariantToCart in CatalogController. This should remove the AjaxCart.
This will also add the item to the cart and redirect you to the shoppingcart page.
When the ShoppingCart page loads in action Cart. Add the following:
if(_workContext.CurrentCustomer.IsGuest())
return new HttpUnauthorizedResult("Cart requires the user to have an account");
This will send the user to the login page giving the impression that the user needs to login to add items to the cart.
Hope this helps
I have a User Control in a Master Page that calculates quantity of products in the shopping basket and writes to page something like shopping cart(2), showing that you have 2 products.
When you add a product to basket, User Control loads first and then Add method of the page executes because of the page life cycle.
So In order to see the new added product takes effect - shopping cart(3) - i need to refresh the page..
What is the best solution in order to see this after add to cart button is pressed with no refreshing the site.
Do I need to use master page's pre_render event?
Having a look at the ASP.Net page life cycle, you'll find that the LoadComplete (for pages only) and PreRender events are called after the postback handlers.
It should be sufficient to move your shopping cart calculation into the User Control's PreRender event.
Just take care of the actual order of event execution, and call your logic accordingly:
http://msdn.microsoft.com/en-us/library/ms178472.aspx
Normally the Master Page UC should subscribe to an event which is fired by the page whenever an item is added.
Best way of doing is to use the custom Event in user control.
How ever if you don't want to use that, you can use a work around. Simply create a property of user control to show count and updates its value in Add method of that page.
I'm learning about ASP.NET, mainly by following through a book, but also making an effort to actually do things along the way. But, I came across an explanation about list controls which I don't understand. This is what it says:
"[in the context of the Smart Tasks panel]...the last option sets the AutoPostBack property of the control. With this option checked, the control will submit the page it's contained in back to the server as soon as the user chooses a new item from the list"
Can you explain this statement for me? Thanks in advance for your help.
For normal client controls (such as a list control with AutoPostBack set to false), when a user chooses an item in the list, the browser does not communicate with the server. There's no network traffic and no delay for your user before they see the results of the choice, but there's also no opportunity to do anything in your server code, like calculate dependent values. If you want to do anything to the screen in response to the choice, you have to use a client-side script.
When AutoPostBack is set to true, selecting an item in the list sends a message to the server (via an HTTP POST). ASP.NET then executes whatever code you have attached to the list's changed event, rebuilds the page, and sends the revised page to the client.
If you set AutoPostBack="true" on a control, when it's value changes, it will automatically postback to the server.
For example if you wanted a dropdown that when changed displayed different data in a table below or something, you might want to postback get the new value so your page could refresh the data.
This is opposed to style of the dropdown and a button beside it you click to postback, so instead of change value, click the button, you can just change the value with AutoPostBack="true".
A ListBox has a SelectedIndexChanged event that you can handle to detect when the selected item in a ListBox has changed. You'd configure it like this:
<asp:ListBox ID="ListBox1" runat="server" OnSelectedIndexChanged="ListBox1_SelectedIndexChanged"/>
protected void ListBox1_SelectedIndexChanged(object sender, EventArgs e)
{
// Do something
}
With AutoPostBack="false" (the default), that event handler doesn't actually happen on the server in "real time". The user has to perform an unrelated action to submit (POST) the form, such as clicking a button, to make that event fire on the server.
If you want to take "real time" action on that event, you set AutoPostBack="true" which makes the form automatically submit every time the selected item is changed.
The benefit - you get "real time" notification of events. The drawback - the page talks a lot more to the server, so each click costs bandwidth and causes client "lag".
Further reading: http://www.dotnetspider.com/resources/189-AutoPostBack-What-How-works.aspx
When a user selects a ListItem (or whatever the collection item is), the page should automatically submit the web form to the server with a POST event.
here's the wikipedia page on HTTP POST events
http://en.wikipedia.org/wiki/HTTP_POST
The responsibility of an asp.net control contained in a Page is to render a part of the html that the user will end up seeing in his browser. Some controls support the AutoPostBack property. What it does is that it makes the control emit some extra javascript that will submit the form whenever the value of that control is changed, so that you can react to this on the server side.
Basically AutoPostBack is used so that whenever there is some change in the controls text or anyother change in the controls property, the page is submitted to the server.
Posting the page means, the page is submitted to the server. Suppose i use a textbox and i make its AutoPostBack = "true", now i write some text into it and click outside the textbox, then the page will refresh.
This refresh indicates that your value which you entered into the textbox has been submitted to the server.
The postback is handled by ASP.NET server. AutoPostBack will automatically post back your page to the server.
Add an event Handler. This will give you a better picture.
In your case of DropDownList: Add an eventhandler: double click the DropDownList, it will route you to an eventhandler:
Write something in that event handler let us say : Response.Write("message");
The page will refresh and you will see your message, this means the page was posted to the server and the server has executed your event handler and displayed you the message.
I hope this was usefull
On one of my ASP.NET pages I have several asp:textbox fields. On this page there is a "confirm order" button with an external url set in its "PostBackUrl" property.
This works well, and the data is sent to the external site. Here comes the question; how do I know that the user clicked the "confirm order" button on "my side?" (I need this to update my order-status field). There is off course no postback happening on my page becasue the form is submitted to the external site.
Maybe it's possible to use some sort of jQuery to hook on the onclick-event that will call a page that will update my order-status?
You'll need to hook into the buttons onClick event, perform a client-side callback to either a web service or Page Method (depending on your preferred setup) on your server to track the click, before allowing the form submission to continue.
Better to set it up so that the button does perform a postback. Then in your click handler you can update your order-status, and then post the data to the third party.