    class Task(models.Model):
        title = models.CharField()
        relates_to = models.ForeignKey(&#39;self&#39;)

https://docs.djangoproject.com/en/dev/ref/models/fields/#foreignkey

Yea you can do that, make the ForeignKey attribute a string:

    class Task(models.Model):
        title = models.CharField()
        relates_to = ForeignKey(to=&#39;Task&#39;)

In depth, you can also cross reference an app&#39;s model by using the dot notation, e.g.

    class Task(models.Model):
        title = models.CharField()
        relates_to = ForeignKey(to=&#39;&lt;app_name&gt;.Task&#39;)  # e.g. &#39;auth.User&#39;

When scrolling on a website I&#39;ve built, using the CSS property `position: fixed` works as expected to keep a navigation bar at the very top of the page.

In Chrome, however, if you use the links in the navigation bar it *sometimes* disappears. Usually, the item you&#39;ve clicked on is still visible, but not always. Sometimes the entire thing disappears. Moving the mouse around brings back part of the element, and scrolling with the scroll wheel or arrow keys just one click brings the element back. You can see it happening (intermittently) on https://nikeplusphp.charanj.it - you might have to click on a few of the navigation the links a few times to see it happen.

I&#39;ve also tried playing with the z-index and the visibility/display type but with no luck.

I came across [this question][1] but the fix didn&#39;t work for me at all. Seems to be a webkit issue as IE and Firefox work just fine.

Is this a known issue or is there a fix to keep fixed elements visible?


  [1]: https://stackoverflow.com/questions/4980502/weird-webkit-issue-with-position-fixed

**Update:**

Only effects elements that have `top: 0;`, I tried `bottom: 0;` and that works as expected.

Fixed element disappears in Chrome

I would like to generate all permutations of a set (a collection), like so:

    Collection: 1, 2, 3
    Permutations: {1, 2, 3}
                  {1, 3, 2}
                  {2, 1, 3}
                  {2, 3, 1}
                  {3, 1, 2}
                  {3, 2, 1}

This isn&#39;t a question of &quot;how&quot;, in general, but more about how most efficiently.
Also, I wouldn&#39;t want to generate ALL permutations and return them, but only generating a single permutation, at a time, and continuing only if necessary (much like Iterators - which I&#39;ve tried as well, but turned out to be less efficient).

I&#39;ve tested many algorithms and approaches and came up with this code, which is most efficient of those I tried:

    public static bool NextPermutation&lt;T&gt;(T[] elements) where T : IComparable&lt;T&gt;
    {
        // More efficient to have a variable instead of accessing a property
        var count = elements.Length;

        // Indicates whether this is the last lexicographic permutation
        var done = true;

        // Go through the array from last to first
        for (var i = count - 1; i &gt; 0; i--)
        {
            var curr = elements[i];

            // Check if the current element is less than the one before it
            if (curr.CompareTo(elements[i - 1]) &lt; 0)
            {
                continue;
            }

            // An element bigger than the one before it has been found,
            // so this isn&#39;t the last lexicographic permutation.
            done = false;

            // Save the previous (bigger) element in a variable for more efficiency.
            var prev = elements[i - 1];

            // Have a variable to hold the index of the element to swap
            // with the previous element (the to-swap element would be
            // the smallest element that comes after the previous element
            // and is bigger than the previous element), initializing it
            // as the current index of the current item (curr).
            var currIndex = i;

            // Go through the array from the element after the current one to last
            for (var j = i + 1; j &lt; count; j++)
            {
                // Save into variable for more efficiency
                var tmp = elements[j];

                // Check if tmp suits the &quot;next swap&quot; conditions:
                // Smallest, but bigger than the &quot;prev&quot; element
                if (tmp.CompareTo(curr) &lt; 0 &amp;&amp; tmp.CompareTo(prev) &gt; 0)
                {
                    curr = tmp;
                    currIndex = j;
                }
            }

            // Swap the &quot;prev&quot; with the new &quot;curr&quot; (the swap-with element)
            elements[currIndex] = prev;
            elements[i - 1] = curr;

            // Reverse the order of the tail, in order to reset it&#39;s lexicographic order
            for (var j = count - 1; j &gt; i; j--, i++)
            {
                var tmp = elements[j];
                elements[j] = elements[i];
                elements[i] = tmp;
            }

            // Break since we have got the next permutation
            // The reason to have all the logic inside the loop is
            // to prevent the need of an extra variable indicating &quot;i&quot; when
            // the next needed swap is found (moving &quot;i&quot; outside the loop is a
            // bad practice, and isn&#39;t very readable, so I preferred not doing
            // that as well).
            break;
        }

        // Return whether this has been the last lexicographic permutation.
        return done;
    }

It&#39;s usage would be sending an array of elements, and getting back a boolean indicating whether this was the last lexicographical permutation or not, as well as having the array altered to the next permutation.

Usage example:

    var arr = new[] {1, 2, 3};

    PrintArray(arr);

    while (!NextPermutation(arr))
    {
        PrintArray(arr);
    }

The thing is that I&#39;m not happy with the speed of the code.

Iterating over all permutations of an array of size 11 takes about 4 seconds.
Although it could be considered impressive, since the amount of possible permutations of a set of size 11 is `11!` which is nearly 40 million.

Logically, with an array of size 12 it will take about 12 times more time, since `12!` is `11! * 12`, and with an array of size 13 it will take about 13 times more time than the time it took with size 12, and so on.

So you can easily understand how with an array of size 12 and more, it really takes a very long time to go through all permutations.

And I have a strong hunch that I can somehow cut that time by a lot (without switching to a language other than C# - because compiler optimization really does optimize pretty nicely, and I doubt I could optimize as good, manually, in Assembly).

Does anyone know any other way to get that done faster?
Do you have any idea as to how to make the current algorithm faster?

Note that I don&#39;t want to use an external library or service in order to do that - I want to have the code itself and I want it to be as efficient as humanly possible.

Generating permutations of a set (most efficiently)

Assume I have this model :

    class Task(models.Model):
        title = models.CharField()

Now I would like that a task may be relates to another task. So I wanted to do this :

    class Task(models.Model):
        title = models.CharField()
        relates_to = ForeignKey(Task)

however I have an error which states that Task is note defined.
Is this &quot;legal&quot; , if not, how should I do something similar to that ?

Can I Make a foreignKey to same model in django?

Assume I have this model :
<pre><code class="hljs language-arduino">class Task(models.Model):
 title = models.CharField()
</code></pre>
Now I would like that a task may be relates to another task. So I wanted to do this :
<pre><code class="hljs language-arduino">class Task(models.Model):
 title = models.CharField()
 relates_to = ForeignKey(Task)
</code></pre>
however I have an error which states that Task is note defined.
Is this "legal" , if not, how should I do something similar to that ?

When I read Django code sometimes, I see in some templates `reverse()`. I am not quite sure what this is but it is used together with HttpResponseRedirect. How and when is this `reverse()` supposed to be used?



What is reverse()?

I have this fields in form:

    city = forms.ModelChoiceField(label=&quot;city&quot;, queryset=MyCity.objects.all())
    district = forms.ModelChoiceField(label=&quot;district&quot;, queryset=MyDistrict.objects.all())
    area = forms.ModelChoiceField(label=&quot;area&quot;, queryset=MyArea.objects.all())

district comes from click on city and area comes from click on area. With  `queryset=MyDistrict.objects.all()` and `queryset=MyArea.objects.all()` form will be very heavy. How can I make querysets empty by default?


Create empty queryset by default in django form fields

In my django powered app there is only one obvious case where &quot;IntegrityError&quot; can arise.  
So, how can I catch that error and display a message using templates?

Django: Catching Integrity Error and showing a customized message using template

I have the following method:

    def _attempt(actor):
        if actor.__class__ != User:
            raise TypeError

Which is called from a view:

    self.object.attempt(self.request.user)

As you can see, the _attempt method expects actor to be type `django.contrib.auth.models.User`, however the object appears to be of type `django.utils.functional.SimpleLazyObject`. Why is this so? And more importantly, how can I convert the `LazyObject` (which apparently is a kind of wrapper for a User object) into a `User` object?

More info on `Request.user` is available here: https://docs.djangoproject.com/en/dev/ref/request-response/#django.http.HttpRequest.user This documentation seems to indicate the `request.user` should be a `User` object...


======Post-edit=====

 I&#39;ve got the following method now: 

    def _attempt(obj, action, actor, msg): 
        actor.is_authenticated() 
        if isinstance(actor, LazyObject): 
            print type(actor) 

I&#39;m passing a user, however the `if` condition is still true, actor is still a `LazyObject`. Why is this so?

request.user returns a SimpleLazyObject, how do I &quot;wake&quot; it?

I have the following django template (http://IP/admin/start/ is assigned to a hypothetical view called view):

    {% for source in sources %}
      &lt;tr&gt;
        &lt;td&gt;{{ source }}&lt;/td&gt;
    
        &lt;td&gt;
        &lt;form action=&quot;/admin/start/&quot; method=&quot;post&quot;&gt;
          {% csrf_token %}
          &lt;input type=&quot;hidden&quot; name=&quot;{{ source.title }}&quot;&gt;
          &lt;input type=&quot;submit&quot; value=&quot;Start&quot; class=&quot;btn btn-primary&quot;&gt;
        &lt;/form&gt;
        &lt;/td&gt;

      &lt;/tr&gt;
    {% endfor %}

`sources` is the `objects.all()` of a Django model being referenced in the view. Whenever a &quot;Start&quot; submit input is clicked, I want the &quot;start&quot; view to use the `{{ source.title}}` data in a function before returning a rendered page. How do I gather information POSTed (in this case, in the hidden input) into Python variables?

Django - taking values from POST request

I&#39;d like to create a many-to-many relationship from and to a user class object.

I have something like this:

    class MyUser(models.Model):
        ...
        blocked_users = models.ManyToManyField(MyUser, blank=True, null=True)



The question is if I can use the class reference inside itself. Or do I have to use `&quot;self&quot;` insead of `&quot;MyUser&quot;` in the `ManyToManyField`? Or is there another (and better) way to do it?


Django Many-to-Many (m2m) Relation to same model

How can I query/filter in Django and ignore the cases of my query-string?

I&#39;ve got something like and like to ignore the case of `my_parameter`:

    MyClass.objects.filter(name=my_parameter)

Django Model - Case-insensitive Query / Filtering

I came across an interesting situation when using this class:

&lt;!-- language: lang-python --&gt;

    class Company(models.Model):
        date = models.DateField()
        time = models.TimeField()

&lt;!-- language: lang-python --&gt;

    c = Company(date=datetime.datetime.now(), time=datetime.datetime.now()) 

Django decides to use `DATETIME_INPUT_FORMATS` defined within the **formats.py** file.
Which makes sense, because I am passing in a `datetime.now()` to both fields.

I think I could make Django to use `DATE_INPUT_FORMATS` and `TIME_INPUT_FORMATS` respectively, if I passed in only the current date and current time in.

Something like this:

    c = Company(date=datetime.date.now(), time=datetime.time.now()) 

But this obviously throws an exception as now doesn&#39;t exist like that.  Is there a different way to achieve this?


How do I get the current date and current time only respectively in Django?

I have a model something like this:

```python
class Task(models.Model):
    progress = models.PositiveIntegerField()
    estimated_days = models.PositiveIntegerField()
```

Now I would like to do a calculation `Sum(progress * estimated_days)` on the database level. Using Django Aggregation I can have the sum for each field but not the summation of multiplication of fields. 

Django Aggregation: Summation of Multiplication of two fields

Is there a way (without using a form) to access a model fields choices value?

I want to do something like `field.choices` and get the list of values either in a view or template.

Content Type	Original Author	Original Content on Stackoverflow
Question	Nuno_147	View Question on Stackoverflow
Solution 1 - Django	Yuji 'Tomita' Tomita	View Answer on Stackoverflow
Solution 2 - Django	Hedde van der Heide	View Answer on Stackoverflow

Can I Make a foreignKey to same model in django?

Django Problem Overview

Django Solutions

Solution 1 - Django

Solution 2 - Django

Generating permutations of a set (most efficiently)

Fixed element disappears in Chrome

Attributions