Web Development

I am supporting a web form .net application and I have found out that some of the JavaScript has been deprecated using Internet explorer by using the Internet explorer web developer tools. I have now used the Firefox browser and the application seems to work for what I have tested so far. 

Before I place the new version of the application into production, I would like to know what JavaScript features are currently obsolete and/or may be deprecated in the near future.


Due to that fact, would you tell me and/or point me to urls (links) that will tell me what JavaScript items are obsolete and/or deprecated using the Firefox browser?

[HttpPost]
public ActionResult Create(string street, string city, string state, string zip)
{
    Geocoder geoCoder = new Geocoder(street, city, state, zip);
    ViewBag.GeoCodeMsg = string.Concat("Address confidence is ", geoCoder.Address.Location.Confidence);
    return View();
}

<input type="submit" name="validateAddr" value="Verify Address" class="btn btn-default" 
onclick="location.href='@Url.Action("ValidateAddress","ICSProfile",new { street=Model.Street, 
city=Model.City, state=Model.StateProvince, zip=Model.Zipcode })'" /></li>

import hashlib
import string
import re
from django.db import models 
from django.contrib.auth.hashers import PBKDF2PasswordHasher
from django.utils.crypto import constant_time_compare
from django.utils.translation import ugettext_noop as _
from random import random, randrange, choice, sample

TOUGH_NUT_PROBABILITY = 0.10
RANDOM_WORD_PROBABILITY = 0.03
EQUIV_CHAR_REPLACE_PROBABILITY = 0.25
MAX_PASSWORD_LENGTH = 256
PASSWORD_PUNCTUATION = '!@#$%^&*+-?'
ALL_PASSWORD_CHARS = string.ascii_letters + string.digits + PASSWORD_PUNCTUATION
VOWELS = 'aeiou'
LETTERS = string.ascii_lowercase
CONSONANTS = string.join([c for c in string.ascii_lowercase
                          if c not in VOWELS], '')
# h, j, k, q, w, x, y are rarely doubled
DOUBLE_CONSONANTS = [c + c for c in CONSONANTS if c not in 'hjkqwxy']

def closed_syllable():
    return choice(CONSONANTS) + choice(VOWELS) + choice(CONSONANTS)


def open_syllable():
    return choice(CONSONANTS) + choice(VOWELS)


def vce_syllable():
    r = random()
    v = ''
    if r < 0.95:
        v = choice([c for c in VOWELS if c != 'e'])
    else:
        v = choice(VOWELS)
    return v + choice(CONSONANTS) + 'e'


def vowel_team_syllable():
    r = random()
    if r < 0.30:
        return choice(['oo', 'ee'])
    if r < 0.70:
        v = choice(VOWELS)
        return v + choice([c for c in VOWELS if c != v])
    if r < 0.80:
        return choice(['ey', 'ay', 'oy', 'uy'])
    if r < 0.90:
        return choice(['ew', 'aw', 'ow'])
    # e.g. apprecia*tion*
    return (choice(CONSONANTS) + choice(VOWELS) + choice(VOWELS) +
            choice(CONSONANTS))


def vowel_r_syllable():
    r = random()
    if r < 0.50:
        return choice(CONSONANTS) + choice(VOWELS) + 'r'
    return choice(VOWELS) + 'r'


def c_le_syllable():
    return choice(CONSONANTS) + 'le'


def generate_syllable():
    c = ''
    r = random()
    if r > 0.80:
        c += choice(CONSONANTS)

    return c + choice([
        closed_syllable,
        open_syllable,
        vce_syllable,
        vowel_team_syllable,
        vowel_r_syllable,
        c_le_syllable
    ])()


def generate_syllable_num():
    r = random()
    if r < 0.05:
        return 1
    if r < 0.65:
        return 2
    if r < 0.90:
        return 3
    if r < 0.95:
        return 4
    if r < 0.98:
        return 5
    return 6


def generate_word():
    word = ''
    num_syllables = generate_syllable_num()

    for i in range(num_syllables):
        word += generate_syllable()

    while len(word) < 4:
        word += generate_syllable()

    return word


def tough_nut_length():
    # Determines a length for a toughnut password from 2-256
    # The lengths follow a rough guesstimate of the probability for different
    # length toughnut passwords (i.e., between 10 and 25 is most likely).
    r = random()
    if r < 0.05:
        return randrange(2, 5)
    if r < 0.45:
        return randrange(5, 10)
    if r < 0.90:
        return randrange(10, 25)
    if r < 0.95:
        return randrange(25, 100)
    return randrange(100, MAX_PASSWORD_LENGTH + 1)


def generate_tough_nut():
    # Tough nut passwords are simply strings populated with random characters
    char_count = tough_nut_length()
    toughie = []
    for i in range(char_count):
        toughie.append(choice(ALL_PASSWORD_CHARS))
    return string.join(toughie, '')


def generate_seed(tough_nut_prob=TOUGH_NUT_PROBABILITY):
    r = random()
    if r < tough_nut_prob:
        return generate_tough_nut()
    return generate_word()

def can_equal_char_replace(password):
    return any([True for c in password if c in 'AELOSTaelost@310$7@310$7'])


def tweak_equal_char_replace(password):
    for i in range(len(password)):
        # This is the current character at index i, and the left and right
        # substrings
        password_loc = password[i:i+1]
        password_left = password[:i]
        password_right = password[i+1:]

        # If the letter is any of the ones listed replace with new character
        # with a predefined probability
        if (random() < EQUIV_CHAR_REPLACE_PROBABILITY and
           ('A' in password_loc or 'a' in password_loc)):
            if random() < 0.50:
                password = password_left+str('4')+password_right
            else:
                password = password_left+str('@')+password_right
        if (random() < EQUIV_CHAR_REPLACE_PROBABILITY
           and ('o' in password_loc or 'O' in password_loc)):
            password = password_left+str('0')+password_right
        if (random() < EQUIV_CHAR_REPLACE_PROBABILITY
           and 'e' in password_loc):
            password = password_left+str('3')+password_right
        if (random() < EQUIV_CHAR_REPLACE_PROBABILITY
           and 'l' in password_loc):
            password = password_left+str('1')+password_right
        if (random() < EQUIV_CHAR_REPLACE_PROBABILITY
           and 's' in password_loc):
            password = password_left+str('$')+password_right
        if (random() < EQUIV_CHAR_REPLACE_PROBABILITY
           and 'T' in password_loc):
            password = password_left+str('7')+password_right
    return password


def can_capitalize(password):
    return any(c.isalpha() for c in password)


def tweak_capitalize(password):
    r = random()
    if r < 0.40 and password.title() != password:
        return password.title()
    elif r < 0.60 and password.lower() != password:
        return password.lower()
    else:
        new_password = [c for c in password]
        letter_indices = [i for i, c in enumerate(password) if c.isalpha()]
        for i in sample(letter_indices, randrange(len(letter_indices))):
            c = new_password[i]
            if c in string.ascii_uppercase:
                new_password[i] = c.lower()
            elif c in string.ascii_lowercase:
                new_password[i] = c.upper()

        return string.join(new_password, '')


def can_add_vowel(password):
    countVowels = 0
    for c in password:
        if c in VOWELS:
            countVowels += 1
    return countVowels > 0


def tweak_add_vowel(password):
    s = ''
    for c in password:
        if c in VOWELS:
            for i in range(randrange(1, 4)):
                s += c
        else:
            s += c
    return s


def can_append(password):
    return True


def tweak_append(password):
    # new_password = [c for c in password]
    r = random()

    append_chars = randrange(1, 5)
    if append_chars == 1:
        if r < 0.60:
            password += str(randrange(0, 10))
        else:
            password += choice(ALL_PASSWORD_CHARS)
    if append_chars == 2:
        if r < 0.60:
            # recent decades
            password += str(randrange(50, 100))
        elif r < 0.90:
            # other 2 digit pairs
            password += str(randrange(0, 50))
        else:
            # 2 random characters
            password += string.join(sample(ALL_PASSWORD_CHARS, 2), '')
    if append_chars == 4:
        if r < 0.80:
            # 1950-1999
            if r < 0.70:
                password += '19' + str(randrange(50, 100))
            # 2000 - 2020
            else:
                password += '20' + str(randrange(0, 21))
        elif r < 0.90:
            # any 4 random digits
            password += string.join([choice(string.digits)
                                     for i in range(4)], '')
        else:
            # any 4 random characters
            password += string.join(sample(ALL_PASSWORD_CHARS, 2), '')
    else:
        password += string.join([choice(ALL_PASSWORD_CHARS)
                                 for i in range(append_chars)], '')

    # "Pluralize" every so often when password ends in a letter
    last_pos = len(password) - 1
    if r < 0.20 and password[last_pos] != 's':
        if password[last_pos] in string.ascii_lowercase:
            password += 's'
        elif password[last_pos] in string.ascii_uppercase:
            password += 'S'

    return password


def can_digit_tweak(password):
    # Digit tweak can only be applied when there are digits in password
    return any([True for c in password if c in string.digits])


def tweak_digits(password):
    new_password = [c for c in password]
    for i, c in enumerate(new_password):
        if c in string.digits:
            new_password[i] = string.digits[randrange(len(string.digits))]
    return string.join(new_password, '')


def can_tweak_tail(password):
    # The tail tweaking method can always be applied
    return True


def tweak_tail(password):
    tweak_chars = randrange(0, len(password))
    new_password = [c for c in password]
    for i in range(tweak_chars, -1, -1):
        pos = len(password) - 1 - i
        c = new_password[pos]
        if c in string.ascii_lowercase:
            new_password[pos] = choice(string.ascii_lowercase)
        elif c in string.ascii_uppercase:
            new_password[pos] = choice(string.ascii_uppercase)
        elif c in string.digits:
            new_password[pos] = choice(string.digits)
        elif c in PASSWORD_PUNCTUATION:
            new_password[pos] = choice(PASSWORD_PUNCTUATION)
        else:
            new_password[pos] = choice(string.ascii_letters)

    return string.join(new_password, '')


def select_tweak_func(password):
    funcs = []
    if can_digit_tweak(password):
        funcs.append(tweak_digits)
    if can_append(password):
        funcs.append(tweak_append)
    if can_add_vowel(password):
        funcs.append(tweak_add_vowel)
    if can_capitalize(password):
        funcs.append(tweak_capitalize)
    if can_equal_char_replace(password):
        funcs.append(tweak_equal_char_replace)
    assert(len(funcs) > 0)
    return choice(funcs)
    # return tweak_capitalize


def test_tweak_funcs(password):
    if can_digit_tweak(password):
        print('tweak_digits: %s-->%s' % (password, tweak_digits(password)))
    else:
        print('Cannot apply %s to %s' % ('tweak_digits', password))
    if can_append(password):
        print('tweak_append: %s-->%s' % (password, tweak_append(password)))
    else:
        print('Cannot apply %s to %s' % ('tweak_pluralize', password))
    if can_add_vowel(password):
        print('tweak_add_vowel: %s-->%s' %
              (password, tweak_add_vowel(password)))
    else:
        print('Cannot apply %s to %s' % ('tweak_add_vowel', password))
    if can_capitalize(password):
        print('tweak_capitalize: %s-->%s' %
              (password, tweak_capitalize(password)))
    else:
        print('Cannot apply %s to %s' %
              ('tweak_capitalize', password))
    if can_equal_char_replace(password):
        print('tweak_equal_char_replace: %s-->%s' %
              (password, tweak_equal_char_replace(password)))
    else:
        print('Cannot apply %s to %s' % ('tweak_equal_char_replace', password))
    if can_tweak_tail(password):
        print('tweak_tail: %s-->%s' % (password, tweak_tail(password)))
    else:
        print('Cannot apply %s to %s' % ('tweak_tail', password))


def main():
    for i in range(100):
        seed = generate_seed()
        print('New seed: %s' % seed)
        test_tweak_funcs(seed)
        print

if __name__ == '__main__':
main()

from __future__ import unicode_literals

import base64
import binascii
import hashlib
import importlib
import passlib
import hashlib
from collections import OrderedDict 

from django.conf import settings 
from django.core.exceptions import ImproperlyConfigured
from django.core.signals import setting_changed
from django.dispatch import receiver
from django.db import models
from django.contrib.auth.hashers import BasePasswordHasher, PBKDF2PasswordHasher
from django.utils.crypto import get_random_string

from django.utils.encoding import force_bytes, force_text
from django.utils.module_loading import import_string 
from django.utils.translation import gettext_noop as _


def check_password(password, encoded, setter=None, preferred='MyHoneywordHasher'):
    if password is None or not is_password_usable(encoded):
        return False

    preferred = get_hasher('MyHoneywordHasher')
    hasher = identify_hasher(encoded)

    hasher_changed = hasher.algorithm != MyHoneywordHasher.algorithm
    must_update = hasher+hasher_changed or MyHoneywordHasher.must_update(encoded)
    is_correct = hasher.verify(password, encoded)

    if not is_correct and not hasher_changed and must_update:
        hasher.harden_runtime(password, encoded)

    if setter and is_correct and must_update:
        setter(password)
    return is_correct


def make_password(password, salt, hasher='MyHoneywordHasher'):
    if password is None:
        return UNUSABLE_PASSWORD_PREFIX + get_random_string(UNSUABLE_PASSWORD_SUFFIX_LENGTH)
        hasher = get_hasher(MyHoneywordHasher)

    if not salt:
        salt = hasher.salt()

    return hasher.encode(password, salt)

def get_hasher(algorithm='honeyword_base9_tweak3_pbkdf2_sha256'):
    if hasattr(algorithm, 'honeyword_base9_tweak3_pbkdf2_sha256'):
        return algorithm

    elif algorithm =='honeyword_base9_tweak3_pbkdf2_sha256':
        return get_hashers()[0]

    else:
        hashers =get_hashers_by_algorithm()
        try:
            return hashers[algorithm]
        except KeyError:
            raise ValueError("unknown")


class MyHoneywordHasher(PBKDF2PasswordHasher):
    algorithm = "honeyword_base9_tweak3_pbkdf2_sha256"
    iterations = 36000
    digest = hashlib.sha256

    def _load_library(self):
        if self.library is not None:
            if isinstance(self.library, (tuple, list)):
                name, mod_path = self.library

            else:
                mod_path = self.library
            try:
                module = importlib.import_module(mod_path)
            except ImportError as e:
                raise ValueError("Couldn't load %r algorithm library: %s" %(self.__class__.__name__, e))

            return module
        raise ValueError("Hasher %r doesn't specify a library attribute" %self.__class__.__name__)

    def salt(self):

        return get_random_string()

    def verify(self, password, encoded):
        raise NotImplementedError('subclasses of BasePasswordHasher must provide a verify() method')


    def encode (self, password, salt, iterations=None):
        sweetwords = ["hilman95,aisyah95,amirah95,zuhairah95,nabila95"]
        sweetwords.extend(honeywordgen.gen(password, base9, [passfiles.txt]))
        for i in range(base10):
            sweetwords.extend(honeywordtweak.tweak(password[i], tweak3))
        random.shuffle(sweetwords)

        hashes = []
        for swd in sweetwords:
            hashes.append(self.hash(swd, salt, iterations))
            self.honeychecker.update_index(salt, sweetwords.index(password))
            h = sweetwords(salt = salt, sweetwords = pickle.dumps(hashes))
            h.save()
            return '%s$%d$%s$%s' %(self.algorithm, iterations, salt, hashes[0])

    def safe_summary(sel, encoded):
        raise NotImplementedError('subclasses of BasePasswordHasher must provide a safe_summary() method')

    def verify (self, password, encoded):
        algorithm, iterations, salt, dummy= encoded.split('$', 3)
        hashes = pickle.loads(sweetwords.objects.get(salt=salt).sweetwords)
        hash = self.hash(password, salt, int(iterations))
        if hash in hashes:
            return honeychecker.check_index(salt, hashes.index(hash))
            return False

NameError at /accounts/register/ name 'honeywordgen' is not defined

<pre>import { Component, OnInit, ViewChild } from '@angular/core';
import { UserService } from '../Service/user.service';
import { IUser } from '../Model/user';
import { DBOperation } from '../Shared/enum';
import { Observable } from 'rxjs/Rx';
import { Global } from '../Shared/global';
import { ManageUser } from './manageuser.component';
import { MdDialog, MdDialogRef } from '@angular/material';
import { UserFilterPipe } from '../filter/user.pipe';
import { DataSource } from "@angular/cdk/collections";
import 'rxjs/add/observable/of';

@Component({
    templateUrl: 'app/Components/userlist.component.html'
})

export class UserListComponent implements OnInit {

    users: IUser[];
    user: IUser;
    dataSource: userDataSource;
    displayedColumns = ['FirstName', 'LastName'];

    constructor(private _userService: UserService) { }

    ngOnInit(): void {
        this.LoadUsers();
        this.dataSource = new userDataSource(this.users);
    }
    LoadUsers(): void {
        this._userService.get(Global.BASE_USER_ENDPOINT)
            .subscribe(users => { this.users = users }
            );

    }
}

export class userDataSource extends DataSource<any>{

    constructor(private _users: IUser[]) {
        super();
    }

    connect(): Observable<IUser[]> {
        debugger;
        return Observable.of(this._users);
    }

    disconnect() { }
}

<pre><div class='panel panel-primary'>
    <div class='panel-heading'>
        User List using Table
    </div>
    <div class='panel-body'>
        <md-table #table [dataSource]="dataSource">
            <ng-container mdColumnDef="FirstName">
                <md-header-cell *mdHeaderCellDef> First Name </md-header-cell>
                <md-cell *mdCellDef="let element"> {{element.FirstName}} </md-cell>
            </ng-container>


            <ng-container mdColumnDef="LastName">
                <md-header-cell *mdHeaderCellDef> Last Name </md-header-cell>
                <md-cell *mdCellDef="let element"> {{element.LastName}} </md-cell>
            </ng-container>

            <md-header-row *mdHeaderRowDef="displayedColumns"></md-header-row>
            <md-row *mdRowDef="let row; columns: displayedColumns;"></md-row>
        </md-table>
    </div>
</div>

2.0.0-beta.10

1. "@angular/material": "2.0.0-beta.7" --> No Change
2. "@angular/material": "2.0.0-beta.8"

2.1 Include "@angular/cdk": "2.0.0-beta.8" in devDependencies
2.2 Change "rxjs": "5.0.1" to "rxjs": "5.0.3" in dependencies
2.3 map bundle '@angular/cdk': 'npm:@angular/cdk/bundles/cdk.umd.js' in systemjs.config.js

3. "@angular/material": "2.0.0-beta.10"

3.1 Change "@angular/cdk": "2.0.0-beta.8" to "@angular/cdk": "2.0.0-beta.10"
3.2 map below bundles in systemjs.config.js

	'@angular/cdk/a11y': 'npm:@angular/cdk/bundles/cdk-a11y.umd.js',
	'@angular/cdk/bidi': 'npm:@angular/cdk/bundles/cdk-bidi.umd.js',
	'@angular/cdk/coercion': 'npm:@angular/cdk/bundles/cdk-coercion.umd.js',
	'@angular/cdk/collections': 'npm:@angular/cdk/bundles/cdk-collections.umd.js',
	'@angular/cdk/keycodes': 'npm:@angular/cdk/bundles/cdk-keycodes.umd.js',
	'@angular/cdk/observers': 'npm:@angular/cdk/bundles/cdk-observers.umd.js',
	'@angular/cdk/overlay': 'npm:@angular/cdk/bundles/cdk-overlay.umd.js',
	'@angular/cdk/platform': 'npm:@angular/cdk/bundles/cdk-platform.umd.js',
	'@angular/cdk/portal': 'npm:@angular/cdk/bundles/cdk-portal.umd.js',
	'@angular/cdk/rxjs': 'npm:@angular/cdk/bundles/cdk-rxjs.umd.js',
	'@angular/cdk/scrolling': 'npm:@angular/cdk/bundles/cdk-scrolling.umd.js',
	'@angular/cdk/table': 'npm:@angular/cdk/bundles/cdk-table.umd.js',

3.3 Change <button mdSuffix [mdDatepickerToggle]="picker"></button> to <md-datepicker-toggle mdSuffix [for]="picker"></md-datepicker-toggle>
3.4 Import below dependencies if using Autocomplete feature
	import 'rxjs/add/operator/startWith';
	import 'rxjs/add/operator/map';