moneropro/monerojnet/views.py

from os import readlink
from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.urls import reverse
import requests
import json
from .models import *
import datetime
from datetime import date, timedelta
from dateutil.relativedelta import relativedelta
from requests.exceptions import ConnectionError, Timeout, TooManyRedirects
import math
import locale
import pandas as pd
from operator import truediv
import pygsheets
import feedparser
from requests import Session
from psaw import PushshiftAPI    #library Pushshift
from django.contrib.staticfiles.storage import staticfiles_storage  

locale.setlocale(locale.LC_ALL, 'en_US.utf8')

api = PushshiftAPI()    

###########################################
# Próximos gráficos
###########################################

def data_prep_posts(subreddit, start_time, end_time, filters, limit):
    if(len(filters) == 0):
        filters = ['id', 'author', 'created_utc', 'domain', 'url', 'title', 'num_comments'] 

    posts = list(api.search_submissions(subreddit=subreddit, after=start_time, before=end_time, filter=filters, limit=limit))

    return pd.DataFrame(posts)

def data_prep_comments(term, start_time, end_time, filters, limit):
    if (len(filters) == 0):
        filters = ['id', 'author', 'created_utc','body', 'permalink', 'subreddit'] 

    comments = list(api.search_comments(q=term, after=start_time, before=end_time, filter=filters, limit=limit))
    return pd.DataFrame(comments) 

def get_latest():
    url = ''
    parameters = {
        'convert':'USD',
    }
    headers = {
        'Accepts': 'application/json',
        'X-CMC_PRO_API_KEY': '',
    }

    session = Session()
    session.headers.update(headers)

    try:
        response = session.get(url, params=parameters)
        data = json.loads(response.text)
        print(data)
    except (ConnectionError, Timeout, TooManyRedirects) as e:
        data = False

    return data

def load_dominance(coin):
    gc = pygsheets.authorize(service_file='service_account_credentials.json')
    sh = gc.open('zcash_bitcoin')
    wks = sh.worksheet_by_title('Sheet7')
    
    values_mat = wks.get_values(start=(3,1), end=(9999,2), returnas='matrix')
    print(len(values_mat))
    Dominance.objects.all().delete()

    for k in range(0,len(values_mat)):
        if values_mat[k][0] and values_mat[k][1]:
            dominance = Dominance()
            dominance.name = coin
            dominance.date = values_mat[k][0]
            dominance.dominance = float(values_mat[k][1].replace(',', '.'))
            if not(dominance.dominance) and not(dominance.date):
                break
            else:
                dominance.save()
        else:
            break
    
    return True

def update_dominance(coin, data):
    dominances = Dominance.objects.order_by('-date')
    for dominance in dominances:
        break
    
    if dominance.date < date.today():
        print('updating')
        if not(data):
            print('error updating dominance')
            return False
        if data:
            dominance = Dominance()
            dominance.name = 'xmr'
            dominance.date = datetime.datetime.strftime(date.today(), '%Y-%m-%d')
            dominance.dominance = float(data['data']['XMR']['quote']['USD']['market_cap_dominance'])
            dominance.save()

            gc = pygsheets.authorize(service_file='service_account_credentials.json')
            sh = gc.open('zcash_bitcoin')
            wks = sh.worksheet_by_title('Sheet7')
            
            values_mat = wks.get_values(start=(3,1), end=(9999,2), returnas='matrix')

            k = len(values_mat)
            date_aux = datetime.datetime.strptime(values_mat[k-1][0], '%Y-%m-%d')
            date_aux2 = datetime.datetime.strftime(date.today(), '%Y-%m-%d')
            date_aux2 = datetime.datetime.strptime(date_aux2, '%Y-%m-%d')
            if date_aux < date_aux2:
                cell = 'B' + str(k + 3)
                wks.update_value(cell, dominance.dominance)
                cell = 'A' + str(k + 3)
                wks.update_value(cell, dominance.date)
            else:
                print('spreadsheet with the latest data already')
                return False
        else:
            print('no data')
            return False
    else:
        print('up to date')
        return False
    
    print('updated')
    return data

def load_rank(coin):
    gc = pygsheets.authorize(service_file='service_account_credentials.json')
    sh = gc.open('zcash_bitcoin')
    wks = sh.worksheet_by_title('Sheet8')
    
    values_mat = wks.get_values(start=(3,1), end=(9999,2), returnas='matrix')
    print(len(values_mat))
    Rank.objects.all().delete()

    for k in range(0,len(values_mat)):
        if values_mat[k][0] and values_mat[k][1]:
            rank = Rank()
            rank.name = coin
            rank.date = values_mat[k][0]
            rank.rank = int(values_mat[k][1].replace(',', '.'))
            if not(rank.rank) and not(rank.date):
                break
            else:
                rank.save()
        else:
            break
    
    return True

def update_rank(coin):
    ranks = Rank.objects.order_by('-date')
    for rank in ranks:
        break

    if rank.date < date.today():
        print('updating')
        data = get_latest()
        if not(data):
            print('error updating rank')
            return False
        if data:
            rank = Rank()
            rank.name = 'xmr'
            rank.date = datetime.datetime.strftime(date.today(), '%Y-%m-%d')
            rank.rank = int(data['data']['XMR']['cmc_rank'])
            rank.save()

            gc = pygsheets.authorize(service_file='service_account_credentials.json')
            sh = gc.open('zcash_bitcoin')
            wks = sh.worksheet_by_title('Sheet8')
            
            values_mat = wks.get_values(start=(3,1), end=(9999,2), returnas='matrix')

            k = len(values_mat)
            date_aux = datetime.datetime.strptime(values_mat[k-1][0], '%Y-%m-%d')
            date_aux2 = datetime.datetime.strftime(date.today(), '%Y-%m-%d')
            date_aux2 = datetime.datetime.strptime(date_aux2, '%Y-%m-%d')
            if date_aux < date_aux2:
                cell = 'B' + str(k + 3)
                wks.update_value(cell, rank.rank)
                cell = 'A' + str(k + 3)
                wks.update_value(cell, rank.date)
            else:
                print('spreadsheet with the latest data already')
                return False
        else:
            print('no data')
            return False
    else:
        print('up to date')
        return False
    
    print('updated')
    return data

# Create your views here.
def index(request):
    symbol = 'xmr'
    now_inflation = 0.001
    now_units = 0
    supply = 0

    #load_dominance('xmr')
    #load_rank('xmr')
    data = update_rank('xmr')
    data = update_dominance('xmr', data)

    coins = Coin.objects.order_by('date').filter(name=symbol)
    if coins:
        for coin in coins:
            if coin.priceusd > 0:
                now_price = coin.priceusd
            if coin.inflation > 0:
                now_inflation = coin.inflation
            if coin.supply > 0:
                supply = int(coin.supply)*10**12
                now_units = supply/(10**12)
    else:
        message = "Website under maintenance. Check back in a few minutes."
        context = {'message': message}
        return render(request, 'monerojnet/maintenance.html', context)

    now_units = locale.format('%.0f', now_units, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'now_inflation': now_inflation, 'now_units': now_units}
    return render(request, 'monerojnet/index.html', context)

def pt(request):
    symbol = 'xmr'
    now_inflation = 0.001
    now_units = 0
    supply = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    if coins:
        for coin in coins:
            if coin.priceusd > 0:
                now_price = coin.priceusd
            if coin.inflation > 0:
                now_inflation = coin.inflation
            if coin.supply > 0:
                supply = int(coin.supply)*10**12
                now_units = supply/(10**12)
    else:
        message = "Website under maintenance. Check back in a few minutes."
        context = {'message': message}
        return render(request, 'monerojnet/maintenance.html', context)

    now_units = locale.format('%.0f', now_units, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'now_inflation': now_inflation, 'now_units': now_units}
    return render(request, 'monerojnet/pt.html', context)

def fr(request):
    symbol = 'xmr'
    now_inflation = 0.001
    now_units = 0
    supply = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    if coins:
        for coin in coins:
            if coin.priceusd > 0:
                now_price = coin.priceusd
            if coin.inflation > 0:
                now_inflation = coin.inflation
            if coin.supply > 0:
                supply = int(coin.supply)*10**12
                now_units = supply/(10**12)
    else:
        message = "Website under maintenance. Check back in a few minutes."
        context = {'message': message}
        return render(request, 'monerojnet/maintenance.html', context)

    now_units = locale.format('%.0f', now_units, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'now_inflation': now_inflation, 'now_units': now_units}
    return render(request, 'monerojnet/fr.html', context)

def artigos(request):
    context = {}
    return render(request, 'monerojnet/artigos.html', context)

def articles(request):
    context = {}
    return render(request, 'monerojnet/articles.html', context)

def reset(request, symbol):
    coins = Coin.objects.order_by('date').filter(name=symbol)
    deleted = 0
    added = 0
    if coins:
        for coin in coins:
            coin.delete()
            deleted += 1
    print("deleted")
    
    get_prices(symbol)
    coins = Coin.objects.order_by('date').filter(name=symbol)
    if coins:
        for coin in coins:
            added += 1

    context = {'added': added, 'deleted': deleted}
    return render(request, 'monerojnet/reset.html', context)

def importer(request):
    Social.objects.all().delete()
    filename = staticfiles_storage.path('import.txt')
    with open(filename) as f:
        content = f.readlines()
        for line in content:
            data = json.loads(line)
            symbol = data['name']
            item = data['subscriberCountTimeSeries']
            dates = []
            subscriberCount = []
            commentsPerHour = []
            postsPerHour = []
            for unit in item:
                date_now = datetime.datetime.strptime('1970-01-01', '%Y-%m-%d')
                date_now += timedelta(int(unit['utcDay']))
                dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d'))
                value = float(unit['count'])
                subscriberCount.append(value)
            item = data['commentsPerHourTimeSeries']
            for unit in item:
                value = float(unit['commentsPerHour'])
                commentsPerHour.append(value)
            item = data['postsPerHourTimeSeries']
            for unit in item:
                value = float(unit['postsPerHour'])
                postsPerHour.append(value)
                
            for i in range(len(dates)-1):
                social = Social()
                social.name = symbol
                social.date = dates[i]
                if i >= len(dates) - len(subscriberCount):
                    social.subscriberCount = subscriberCount[i-len(subscriberCount)]
                else: 
                    social.subscriberCount = 0
                if i >= len(dates) - len(commentsPerHour):
                    social.commentsPerHour = commentsPerHour[i-(len(dates) - len(commentsPerHour))]
                else: 
                    social.commentsPerHour = 0
                if i >= len(dates) - len(postsPerHour):
                    social.postsPerHour = postsPerHour[i-(len(dates) - len(postsPerHour))]
                else: 
                    social.postsPerHour = 0 
                social.save()

    message = "Dados importados"
    context = {'message': message}
    return render(request, 'monerojnet/importer.html', context)

def check_new_social(symbol):
    date_now = datetime.datetime.strftime(date.today(), '%Y-%m-%d')
    socials = Social.objects.filter(name=symbol).filter(date=date_now)

    print('here 1')
    if not(socials):
        print('here 2')
        request = 'https://www.reddit.com/r/'+ symbol +'/about.json'
        response = requests.get(request, headers = {'User-agent': 'Checking new social data'})
        data = json.loads(response.content)    
        data = data['data']
        subscribers = data['subscribers']
        social = Social()
        social.name = symbol
        social.date = date_now
        social.subscriberCount = subscribers

        date_aux = date.today()
        date_aux = datetime.datetime.strftime(date_aux, '%Y-%m-%d')
        date_aux = datetime.datetime.strptime(date_aux, '%Y-%m-%d')
        timestamp1 = int(datetime.datetime.timestamp(date_aux))

        timestamp2 = int(timestamp1 - 86400)
        limit = 1000
        filters = []
        data = data_prep_posts(symbol, timestamp2, timestamp1, filters, limit)
        print(len(data))
        social.postsPerHour = len(data)/24

        timestamp2 = int(timestamp1 - 7200)
        limit = 1000
        data = data_prep_comments(symbol, timestamp2, timestamp1, filters, limit)
        print(len(data))
        social.commentsPerHour = len(data)/2
        social.save()
    return True

def social(request):
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    dates = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    for social in socials:
        dates.append(datetime.datetime.strftime(social.date, '%Y-%m-%d'))
        if social.subscriberCount > last_btc:
            last_btc = social.subscriberCount
            social_btc.append(social.subscriberCount)       
        else:
            social_btc.append(last_btc)   
        socialscrypto = Social.objects.filter(date=social.date).filter(name='CryptoCurrency')
        if socialscrypto:
            for socialcrypto in socialscrypto:
                if socialcrypto.subscriberCount > last_crypto:
                    social_crypto.append(socialcrypto.subscriberCount)
                    last_crypto = socialcrypto.subscriberCount
                else:
                    social_crypto.append(last_crypto)
        else:
            social_crypto.append(last_crypto)
        socialsxmr = Social.objects.filter(date=social.date).filter(name='Monero')
        if socialsxmr:
            for socialxmr in socialsxmr:
                if socialxmr.subscriberCount > last_xmr:
                    social_xmr.append(socialxmr.subscriberCount)
                    last_xmr = socialxmr.subscriberCount
                else:
                    social_xmr.append(last_xmr)
        else:
            social_xmr.append(last_xmr)

    last_xmr = locale.format('%.0f', last_xmr, grouping=True)
    last_btc = locale.format('%.0f', last_btc, grouping=True)
    last_crypto = locale.format('%.0f', last_crypto, grouping=True)

    context = {'dates': dates, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'social_btc': social_btc, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto}
    return render(request, 'monerojnet/social.html', context)

def social2(request):
    dates = []
    social_btc = []
    last_btc = 0
    N = 1

    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    for social in socials:
        coins = Coin.objects.filter(date=social.date).filter(name='btc')
        if coins:
            for coin in coins:
                if social.subscriberCount > 0 and coin.priceusd > 0 and coin.supply > 0:
                    last_btc = ((coin.priceusd*coin.supply)**N)/social.subscriberCount
                    social_btc.append(last_btc)       
                    dates.append(datetime.datetime.strftime(social.date, '%Y-%m-%d'))
    dates2 = []
    social_xmr = []
    last_xmr = 0
    N = 1

    socials = Social.objects.order_by('date').filter(name='Monero')
    for social in socials:
        coins = Coin.objects.filter(date=social.date).filter(name='xmr')
        if coins:
            for coin in coins:
                if social.subscriberCount > 0 and coin.priceusd > 0 and coin.supply > 0:
                    last_xmr = ((coin.priceusd*coin.supply)**N)/social.subscriberCount
                    social_xmr.append(last_xmr)       
                    dates2.append(datetime.datetime.strftime(social.date, '%Y-%m-%d'))
    
    last_xmr = '$' + locale.format('%.0f', last_xmr, grouping=True)
    last_btc = '$' + locale.format('%.0f', last_btc, grouping=True)
       
    context = {'dates': dates, 'dates2': dates2, 'social_btc': social_btc, 'social_xmr': social_xmr, 'last_xmr': last_xmr, 'last_btc': last_btc}
    return render(request, 'monerojnet/social2.html', context)

def social3(request):
    dates = []
    social_xmr = []
    last_xmr = 0.001
    social_crypto = []
    last_crypto = 0.001

    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    for social in socials:
        dates.append(datetime.datetime.strftime(social.date, '%Y-%m-%d'))
        socialsxmr = Social.objects.filter(date=social.date).filter(name='Monero')
        if socialsxmr:
            for socialxmr in socialsxmr:
                if socialxmr.subscriberCount > 0.001 and social.subscriberCount > 0.001:
                    if socialxmr.subscriberCount/social.subscriberCount > 0.001:
                        last_xmr = 100*(socialxmr.subscriberCount/social.subscriberCount)
                        social_xmr.append(last_xmr)
                    else:
                        social_xmr.append(last_xmr)
                else:
                    social_xmr.append(last_xmr)
        else:
            social_xmr.append(last_xmr)
        
        socialscrypto = Social.objects.filter(date=social.date).filter(name='CryptoCurrency')
        if socialscrypto:
            for socialcrypto in socialscrypto:
                if socialcrypto.subscriberCount > 0.001 and social.subscriberCount > 0.001:
                    if socialcrypto.subscriberCount/social.subscriberCount > 0.001:
                        last_crypto = 100*(socialcrypto.subscriberCount/social.subscriberCount)
                        social_crypto.append(last_crypto)
                    else:
                        social_crypto.append(last_crypto)
                else:
                    social_crypto.append(last_crypto)
        else:
            social_crypto.append(last_crypto)

    last_xmr = locale.format('%.1f', last_xmr, grouping=True)+ '%'
    last_crypto = locale.format('%.1f', last_crypto, grouping=True)+ '%'

    context = {'dates': dates, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'last_xmr': last_xmr, 'last_crypto': last_crypto}
    return render(request, 'monerojnet/social3.html', context)

def social4(request):
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    dates = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    for social in socials:
        dates.append(datetime.datetime.strftime(social.date, '%Y-%m-%d'))
        if social.subscriberCount > last_btc:
            last_btc = social.subscriberCount
            social_btc.append(social.subscriberCount)       
        else:
            social_btc.append(last_btc)   
        socialscrypto = Social.objects.filter(date=social.date).filter(name='CryptoCurrency')
        if socialscrypto:
            for socialcrypto in socialscrypto:
                if socialcrypto.subscriberCount > last_crypto:
                    social_crypto.append(socialcrypto.subscriberCount)
                    last_crypto = socialcrypto.subscriberCount
                else:
                    social_crypto.append(last_crypto)
        else:
            social_crypto.append(last_crypto)
        socialsxmr = Social.objects.filter(date=social.date).filter(name='Monero')
        if socialsxmr:
            for socialxmr in socialsxmr:
                if socialxmr.subscriberCount > last_xmr:
                    social_xmr.append(socialxmr.subscriberCount)
                    last_xmr = socialxmr.subscriberCount
                else:
                    social_xmr.append(last_xmr)
        else:
            social_xmr.append(last_xmr)

    N = 30
    last_btc = ''
    speed_btc = []
    for i in range(len(social_btc)):
        if i < N:
            speed_btc.append(last_btc)
        else:
            if social_btc[i-N] != 0 and social_btc[i] - social_btc[i-N] != 0:
                last_btc = 100*(social_btc[i] - social_btc[i-N])/social_btc[i-N]
                if last_btc < 0.2:
                    last_btc = 0.2
                if last_btc > 1000:
                    last_btc = ''
            else:
                last_btc = ''
            speed_btc.append(last_btc)

    last_btc = ''
    newcomers_btc = []
    for i in range(len(social_btc)):
        if i < N:
            newcomers_btc.append(last_btc)
        else:
            last_btc = (social_btc[i] - social_btc[i-N])
            if last_btc < 10:
                last_btc = ''
            newcomers_btc.append(last_btc)

    last_crypto = ''
    speed_crypto = []
    for i in range(len(social_crypto)):
        if i < N:
            speed_crypto.append(last_crypto)
        else:
            if social_crypto[i-N] != 0 and social_crypto[i] - social_crypto[i-N] != 0:
                last_crypto = 100*(social_crypto[i] - social_crypto[i-N])/social_crypto[i-N]
                if last_crypto < 0.2:
                    last_crypto = 0.2
                if last_crypto > 1000:
                    last_crypto = ''
            else:
                last_crypto = ''
            speed_crypto.append(last_crypto)

    last_crypto = ''
    newcomers_crypto = []
    for i in range(len(social_crypto)):
        if i < N:
            newcomers_crypto.append(last_crypto)
        else:
            last_crypto = (social_crypto[i] - social_crypto[i-N])
            if last_crypto < 2:
                last_crypto = ''
            newcomers_crypto.append(last_crypto)


    last_xmr = ''
    speed_xmr = []
    for i in range(len(social_xmr)):
        if i < N:
            speed_xmr.append(last_xmr)
        else:
            if social_xmr[i-N] != 0 and social_xmr[i] - social_xmr[i-N] != 0:
                last_xmr = 100*(social_xmr[i] - social_xmr[i-N])/social_xmr[i-N]
                if last_xmr < 0.2:
                    last_xmr = 0.2
                if last_xmr > 1000:
                    last_xmr = ''
            else:
                last_xmr = ''
            speed_xmr.append(last_xmr)

    last_xmr = ''
    newcomers_xmr = []
    for i in range(len(social_xmr)):
        if i < N:
            newcomers_xmr.append(last_xmr)
        else:
            last_xmr = (social_xmr[i] - social_xmr[i-N])
            if last_xmr < 0:
                last_xmr = ''
            newcomers_xmr.append(last_xmr)

    last_xmr = locale.format('%.0f', last_xmr, grouping=True)
    last_btc = locale.format('%.0f', last_btc, grouping=True)
    last_crypto = locale.format('%.0f', last_crypto, grouping=True)

    context = {'dates': dates, 'speed_xmr': speed_xmr, 'speed_crypto': speed_crypto, 'speed_btc': speed_btc, 'newcomers_xmr': newcomers_xmr, 'newcomers_btc': newcomers_btc, 'newcomers_crypto': newcomers_crypto, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto}
    return render(request, 'monerojnet/social4.html', context)

def social5(request):
    symbol = 'xmr'
    transactions = []
    pricexmr = []
    dates = []
    now_transactions = 0
    dates = []
    social_xmr = []
    last_xmr = 0
    coins = Coin.objects.order_by('date').filter(name=symbol)
    if coins:
        for coin in coins:
            dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
            socials = Social.objects.filter(date=coin.date).filter(name='Monero')
            if socials:
                for social in socials:
                    if social.subscriberCount > last_xmr:
                        last_xmr = social.subscriberCount
                        social_xmr.append(social.subscriberCount)       
                    else:
                        social_xmr.append(last_xmr)   
            else:
                social_xmr.append(last_xmr)
            if coin.transactions > 200:
                transactions.append(coin.transactions)
                now_transactions = coin.transactions       
            else:
                transactions.append('')
            if coin.priceusd > 0.001:
                pricexmr.append(coin.priceusd)
            else:
                pricexmr.append('')
    else:
        pricexmr.append('')
        transactions.append('')
    
    last_xmr = locale.format('%.0f', last_xmr, grouping=True)
    now_transactions = locale.format('%.0f', now_transactions, grouping=True)

    context = {'dates': dates, 'social_xmr': social_xmr, 'last_xmr': last_xmr, 'now_transactions': now_transactions, 'transactions': transactions, 'pricexmr': pricexmr}
    return render(request, 'monerojnet/social5.html', context)

def social6(request):
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    dates = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    for social in socials:
        dates.append(datetime.datetime.strftime(social.date, '%Y-%m-%d'))
        if social.commentsPerHour*24 < last_btc/4:
            social_btc.append(last_btc)
        else:
            social_btc.append(social.commentsPerHour*24)
            last_btc = social.commentsPerHour*24
        socialscrypto = Social.objects.filter(date=social.date).filter(name='CryptoCurrency')
        if socialscrypto:
            for socialcrypto in socialscrypto:
                if socialcrypto.commentsPerHour*24 < last_crypto/4:
                    social_crypto.append(last_crypto)
                else:
                    social_crypto.append(socialcrypto.commentsPerHour*24)
                    last_crypto = socialcrypto.commentsPerHour*24
        else:
            social_crypto.append(last_crypto)
        socialsxmr = Social.objects.filter(date=social.date).filter(name='Monero')
        if socialsxmr:
            for socialxmr in socialsxmr:
                if socialxmr.commentsPerHour*24 < last_xmr/4:
                    social_xmr.append(last_xmr)
                else:
                    social_xmr.append(socialxmr.commentsPerHour*24)
                    last_xmr = socialxmr.commentsPerHour*24

        else:
            social_xmr.append(last_xmr)

    last_xmr = locale.format('%.0f', last_xmr, grouping=True)
    last_btc = locale.format('%.0f', last_btc, grouping=True)
    last_crypto = locale.format('%.0f', last_crypto, grouping=True)

    context = {'dates': dates, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'social_btc': social_btc, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto}
    return render(request, 'monerojnet/social6.html', context)

def social7(request):
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    dates = []
    social_xmr = []
    social_crypto = []
    social_btc = []
    last_xmr = 0
    last_btc = 0
    last_crypto = 0
    socials = Social.objects.order_by('date').filter(name='Bitcoin')
    for social in socials:
        dates.append(datetime.datetime.strftime(social.date, '%Y-%m-%d'))
        social_btc.append(social.postsPerHour*24)
        last_btc = social.postsPerHour*24
        socialscrypto = Social.objects.filter(date=social.date).filter(name='CryptoCurrency')
        if socialscrypto:
            for socialcrypto in socialscrypto:
                social_crypto.append(socialcrypto.postsPerHour*24)
                last_crypto = socialcrypto.postsPerHour*24
        else:
            social_crypto.append(last_crypto)
        socialsxmr = Social.objects.filter(date=social.date).filter(name='Monero')
        if socialsxmr:
            for socialxmr in socialsxmr:
                social_xmr.append(socialxmr.postsPerHour*24)
                last_xmr = socialxmr.postsPerHour*24

        else:
            social_xmr.append(last_xmr)

    last_xmr = locale.format('%.0f', last_xmr, grouping=True)
    last_btc = locale.format('%.0f', last_btc, grouping=True)
    last_crypto = locale.format('%.0f', last_crypto, grouping=True)

    context = {'dates': dates, 'social_xmr': social_xmr, 'social_crypto': social_crypto, 'social_btc': social_btc, 'last_xmr': last_xmr, 'last_btc': last_btc, 'last_crypto': last_crypto}
    return render(request, 'monerojnet/social7.html', context)

def pricelog(request):
    symbol = 'xmr'
    now_price = 0
    now_sf = 0
    now_inflation = 0
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    maximum = 0
    supply = 0
    dates = []
    color = []
    values = []

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        values.append(coin.priceusd)
        if coin.priceusd < 0.01:
            coin.priceusd = 0.01
        if coin.stocktoflow < 0.1:
            coin.stocktoflow = 0.1
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        if now_price > maximum:
            maximum = now_price
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        supply = int(coin.supply)*10**12
        count += 1

    count = 0
    for count in range(650):
        date_now = date.today() + timedelta(count)
        dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d'))
        reward = (2**64 -1 - supply) >> 19
        if reward < 0.6*(10**12):
            reward = 0.6*(  10**12)
        supply += int(720*reward)

    now_price = "$"+ locale.format('%.2f', now_price, grouping=True)
    now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True)
    maximum = "$"+ locale.format('%.2f', maximum, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color}
    return render(request, 'monerojnet/pricelog.html', context)

def movingaverage(request):
    symbol = 'xmr'
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    dates = []
    color = []
    values = []
    average1 = []
    average2 = []
    total = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        if coin.priceusd < 0.2:
            coin.priceusd = 0.2
        total += coin.priceusd
        values.append(coin.priceusd)
        if count < 1460:
            aux = total/(730 + count/2)
            if aux < 0.2:
                aux = 0.2
            average1.append(aux)
            average2.append(aux*5)
            if coin.priceusd > 5*aux:
                new_color = 1
            if coin.priceusd < aux:
                new_color = 0
            else:
                new_color = coin.priceusd/(5*aux)
            color.append(new_color)
        else:
            color.append(new_color)
        
        count += 1
    
    n = 1460
    median = pd.Series(values).rolling(window=n).mean().iloc[n-1:].values

    #for count in range(1460):
    #    average1.append('')
    #    average2.append('')
    for item in median:
        average1.append(item)
        average2.append(item*5)

    context = {'values': values, 'dates': dates, 'color': color, 'average1': average1, 'average2': average2}
    return render(request, 'monerojnet/movingaverage.html', context)

def powerlaw(request):
    symbol = 'xmr'
    now_price = 0
    now_sf = 0
    now_inflation = 0
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    maximum = 0
    dates = []
    counter = []
    years = []
    line3 = []
    line2 = []
    line1 = []
    a3 = 0.00000000000000000009
    a2 = 0.0000000000000000000000008
    a1 = 0.00000000000000000000000002
    b3 = ((math.log(477,10)-math.log(5.01,10))/(math.log(2511,10)-math.log(1231,10)))
    b2 = ((math.log(95,10)-math.log(0.23,10))/(math.log(3297,10)-math.log(1468,10)))
    b1 = ((math.log(84,10)-math.log(0.39,10))/(math.log(3507,10)-math.log(1755,10)))
    color = []
    values = []

    yearnumber = 2014
    days = 1200
    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        if coin.priceusd < 0.01:
            continue
        days += 1
        price3 = a3*(days**b3)
        price2 = a2*(days**b2)
        price1 = a1*(days**b1)
        line3.append(price3)
        line2.append(price2)
        line1.append(price1)
        counter.append(days)
        if coin.date.year > yearnumber:
            yearnumber += 1
            years.append(yearnumber)
            dates.append(days)
        values.append(coin.priceusd)
        if coin.priceusd < 0.01:
            coin.priceusd = 0.01
        if coin.stocktoflow < 0.1:
            coin.stocktoflow = 0.1
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        if now_price > maximum:
            maximum = now_price
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        count += 1

    for count in range(1, 3650):
        date_now = date.today() + timedelta(count)   
        values.append('')     
        days += 1
        price3 = a3*(days**b3)
        price2 = a2*(days**b2)
        price1 = a1*(days**b1)
        line3.append(price3)
        line2.append(price2)
        line1.append(price1)
        counter.append(days)
        if date_now.year > yearnumber:
            yearnumber += 1
            years.append(yearnumber)
            dates.append(days)   

    now_price = "$"+ locale.format('%.2f', now_price, grouping=True)
    now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True)
    maximum = "$"+ locale.format('%.2f', maximum, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'now_inflation': now_inflation, 
    'now_sf': now_sf, 'color': color, 'years': years, 'counter': counter, 'line1': line1, 'line2': line2, 'line3': line3}
    return render(request, 'monerojnet/powerlaw.html', context)

def pricelin(request):
    symbol = 'xmr'
    now_price = 0
    now_sf = 0
    now_inflation = 0
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    maximum = 0
    supply = 0
    dates = []
    color = []
    values = []

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        values.append(coin.priceusd)
        if coin.priceusd < 0.01:
            coin.priceusd = 0.01
        if coin.stocktoflow < 0.1:
            coin.stocktoflow = 0.1
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        if now_price > maximum:
            maximum = now_price
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        supply = int(coin.supply)*10**12
        count += 1

    count = 0
    for count in range(650):
        date_now = date.today() + timedelta(count)
        dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d'))
        reward = (2**64 -1 - supply) >> 19
        if reward < 0.6*(10**12):
            reward = 0.6*(  10**12)
        supply += int(720*reward)
        stock = (100/(100*reward*720*365/supply))**1.65         

    now_price = "$"+ locale.format('%.2f', now_price, grouping=True)
    now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True)
    maximum = "$"+ locale.format('%.2f', maximum, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color}
    return render(request, 'monerojnet/pricelin.html', context)

def pricesats(request):
    symbol = 'xmr'
    projection = []
    color = []
    values = []
    dates = []
    now_price = 0
    maximum = 0
    bottom = 1
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        if coin.pricebtc > 0.001:
            values.append(coin.pricebtc)
        else:
            values.append('')
        date_aux1 = datetime.datetime.strptime('2021-03-15', '%Y-%m-%d')
        date_aux2 = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        date_aux2 = datetime.datetime.strptime(date_aux2, '%Y-%m-%d')
        if date_aux2 < date_aux1:
            lastprice = coin.pricebtc
            projection.append('')
        else:
            day = date_aux2 - timedelta(1700)
            coin_aux1 = Coin.objects.filter(name=symbol).get(date=day)
            day = date_aux2 - timedelta(1701)
            coin_aux2 = Coin.objects.filter(name=symbol).get(date=day)
            if coin_aux1 and coin_aux2:
                lastprice += (coin_aux1.pricebtc/coin_aux2.pricebtc-1)*lastprice*0.75
                projection.append(lastprice)
            else:
                projection.append('')
        if coin.pricebtc > 0:
            now_price = coin.pricebtc
        if now_price > maximum:
            maximum = now_price
        if now_price > 0:
            if now_price < bottom:
                bottom = now_price
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        count += 1

    count = 0
    for count in range(300):
        date_now = date.today() + timedelta(count)
        dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d'))
        day = date_now - timedelta(1900)
        coin_aux1 = Coin.objects.filter(name=symbol).get(date=day)
        day = date_now - timedelta(1901)
        coin_aux2 = Coin.objects.filter(name=symbol).get(date=day)
        if coin_aux1 and coin_aux2:
            lastprice += (coin_aux1.pricebtc/coin_aux2.pricebtc-1)*lastprice*0.75
            projection.append(lastprice)
        else:
            projection.append('')
    
    now_price = locale.format('%.4f', now_price, grouping=True) + ' BTC'
    maximum = locale.format('%.4f', maximum, grouping=True) + ' BTC'
    bottom = locale.format('%.4f', bottom, grouping=True) + ' BTC'

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_price': now_price, 'color': color, 'projection': projection, 'bottom': bottom}
    return render(request, 'monerojnet/pricesats.html', context)

def fractal(request):
    symbol = 'xmr'
    dates1 = []
    dates2 = []
    cycle1 = []
    cycle2 = []
    now_multiple = 0
    maximum = 0

    count1 = 1
    count2 = 1
    date1_aux = datetime.datetime(2017, 12, 29) 
    date2_aux = datetime.datetime(2014, 6, 21)
    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        date3_aux = datetime.datetime.combine(coin.date, datetime.time(0, 0))
        if date3_aux < date1_aux and date3_aux > date2_aux:
            start_inflation = coin.inflation
            cycle1.append(coin.priceusd/5)
            dates1.append(count1/12.7)
            if (coin.priceusd/5) > maximum:
                maximum = coin.priceusd/5
            count1 += 1
        elif date3_aux > date1_aux:
            cycle2.append(coin.priceusd/477.12)
            dates2.append(count2/20.7) #24
            now_multiple = coin.priceusd/477.12
            count2 += 0.86

    now_multiple = locale.format('%.2f', now_multiple, grouping=True) + 'x'
    maximum = locale.format('%.2f', maximum, grouping=True) + 'x'

    context = {'cycle1': cycle1, 'cycle2': cycle2, 'dates1': dates1, 'dates2': dates2, 'now_multiple': now_multiple, 'maximum': maximum}
    return render(request, 'monerojnet/fractal.html', context)

def inflationfractal(request):
    symbol = 'xmr'
    dates1 = []
    dates2 = []
    cycle1 = []
    cycle2 = []
    now_multiple = 0
    maximum = 0

    current_inflation = 0
    start_inflation = 0
    count1 = 1
    count2 = 1
    date1_aux = datetime.datetime(2017, 12, 29) 
    date2_aux = datetime.datetime(2014, 6, 21)
    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        date3_aux = datetime.datetime.combine(coin.date, datetime.time(0, 0))
        if date3_aux < date1_aux and date3_aux > date2_aux:
            start_inflation = coin.inflation
            current_inflation = start_inflation
            cycle1.append(coin.priceusd/5)
            dates1.append(count1/12.7)
            if (coin.priceusd/5) > maximum:
                maximum = coin.priceusd/5
            count1 += 1
        elif date3_aux > date1_aux:
            if (coin.inflation/current_inflation) > 1.15 or (coin.inflation/current_inflation) < 0.85:
                coin.inflation = current_inflation
            else:
                current_inflation = coin.inflation
            delta = math.sqrt(coin.inflation/start_inflation)
            cycle2.append(delta*coin.priceusd/477.12)
            dates2.append(count2/20.55) #24
            now_multiple = delta*coin.priceusd/477.12
            count2 += 0.86

    now_multiple = locale.format('%.2f', now_multiple, grouping=True) + 'x'
    maximum = locale.format('%.2f', maximum, grouping=True) + 'x'

    context = {'cycle1': cycle1, 'cycle2': cycle2, 'dates1': dates1, 'dates2': dates2, 'now_multiple': now_multiple, 'maximum': maximum}
    return render(request, 'monerojnet/inflationfractal.html', context)

def golden(request):
    symbol = 'xmr'
    dates = []
    prices = []

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        firstdate = coin.date
        break     

    day = firstdate - timedelta(350)
    for i in range(350):
        dates.append(datetime.datetime.strftime(day, '%Y-%m-%d'))
        prices.append(0.2)

    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        if coin.priceusd > 0.2:
            prices.append(coin.priceusd)
        else:
            prices.append(0.2)
    
    n = 350
    median = pd.Series(prices).rolling(window=n).mean().iloc[n-1:].values
    m_350 = []
    m_350_0042 = []
    m_350_0060 = []
    m_350_0200 = []
    m_350_0300 = []
    m_350_0500 = []
    m_350_0800 = []
    m_350_1300 = []
    for i in range(350):
        m_350.append('')
        m_350_0042.append('')
        m_350_0060.append('')
        m_350_0200.append('')
        m_350_0300.append('')
        m_350_0500.append('')
        m_350_0800.append('')
        m_350_1300.append('')
    for item in median:
        m_350.append(float(item))
        m_350_0042.append(float(item)*0.42)
        m_350_0060.append(float(item)*0.60)
        m_350_0200.append(float(item)*2.00)
        m_350_0300.append(float(item)*3.00)
        m_350_0500.append(float(item)*5.00)
        m_350_0800.append(float(item)*8.00)
        m_350_1300.append(float(item)*13.00)

    n = 120
    median = pd.Series(prices).rolling(window=n).mean().iloc[n-1:].values
    m_111 = []
    for i in range(120):
        m_111.append('')
    for item in median:
        m_111.append(float(item))

    i = 0
    down = True
    price_cross = []
    for price in prices:
        if m_111[i] != '' and m_350_0200[i] != '':
            if down == True and m_111[i] > m_350_0200[i]:
                down = False
                price_cross.append(price)
            elif price > m_350_0500[i]:
                price_cross.append(price)
            elif down == False and m_111[i] < m_350_0200[i]:
                down = True
            else:
                price_cross.append('')
        else:
            price_cross.append('')
        i += 1

    context = {'dates': dates, 'prices': prices, 'm_350': m_350, 'm_350_0042': m_350_0042, 'm_350_0060': m_350_0060, 'm_350_0200': m_350_0200, 'm_350_0300': m_350_0300, 
    'm_350_0500': m_350_0500, 'm_350_0800': m_350_0800, 'm_350_1300': m_350_1300, 'median': median, 'm_111': m_111, 'price_cross': price_cross}
    return render(request, 'monerojnet/golden.html', context)

def competitors(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    count = 0
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0

    count = 0
    coins_xmr = Coin.objects.order_by('date').filter(name='xmr')
    for coin_xmr in coins_xmr:
        if coin_xmr.priceusd:
            if count > 30:
                xmr.append(coin_xmr.priceusd/5.01)
                now_xmr = coin_xmr.priceusd/5.01
            dates.append(count)
            count += 1
        elif count <= 63:
            continue
        else:
            xmr.append('')

    count = 0
    coins_dash = Coin.objects.order_by('date').filter(name='dash')
    for coin_dash in coins_dash:
        count += 1
        if coin_dash.priceusd and count > 130:
            dash.append(coin_dash.priceusd/14.7)
            now_dash = coin_dash.priceusd/14.7
        elif count <= 130:
            continue
        else:
            dash.append('')
        dates.append(count)

    count = 0
    coins_grin = Coin.objects.order_by('date').filter(name='grin')
    for coin_grin in coins_grin:
        count += 1
        if coin_grin.priceusd and count > 155:
            grin.append(coin_grin.priceusd/6.37)
            now_grin = coin_grin.priceusd/6.37
        elif count <= 155:
            continue
        else:
            grin.append('')
        dates.append(count)

    count = 0
    coins_zcash = Coin.objects.order_by('date').filter(name='zec')
    for coin_zcash in coins_zcash:
        count += 1
        if coin_zcash.priceusd and count > 434:
            zcash.append(coin_zcash.priceusd/750)
            now_zcash = coin_zcash.priceusd/750
        elif count <= 434:
            continue
        else:
            zcash.append('')
        dates.append(count)

    now_dash = locale.format('%.2f', now_dash, grouping=True) 
    now_grin = locale.format('%.2f', now_grin, grouping=True)
    now_zcash = locale.format('%.2f', now_zcash, grouping=True)
    now_xmr = locale.format('%.2f', now_xmr, grouping=True)

    context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 
    'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates}
    return render(request, 'monerojnet/competitors.html', context)

def marketcap(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0

    coins_xmr = Coin.objects.order_by('date').filter(name='xmr')
    for coin_xmr in coins_xmr:
        dates.append(datetime.datetime.strftime(coin_xmr.date, '%Y-%m-%d'))
        if coin_xmr.priceusd:
            xmr.append(coin_xmr.priceusd*coin_xmr.supply)
            now_xmr = coin_xmr.priceusd*coin_xmr.supply
        else:
            xmr.append('')

        try:
            coin_dash = Coin.objects.filter(name='dash').get(date=coin_xmr.date)
            now_dash = coin_dash.priceusd*coin_dash.supply
            if now_dash > 1000000:
                dash.append(now_dash)
            else:
                dash.append('')
        except:
            dash.append('')

        try:
            coin_zcash = Coin.objects.filter(name='zec').get(date=coin_xmr.date)
            now_zcash = coin_zcash.priceusd*coin_zcash.supply
            if now_zcash > 1000000:
                zcash.append(now_zcash)
            else:
                zcash.append('')
        except:
            zcash.append('')

        try:
            coin_grin = Coin.objects.filter(name='grin').get(date=coin_xmr.date)
            now_grin = coin_grin.priceusd*coin_grin.supply
            if now_grin > 1000000:
                grin.append(now_grin)
            else:
                grin.append('')
        except:
            grin.append('')

    now_dash = '$'+locale.format('%.0f', now_dash, grouping=True) 
    now_grin = '$'+locale.format('%.0f', now_grin, grouping=True)
    now_zcash = '$'+locale.format('%.0f', now_zcash, grouping=True)
    now_xmr = '$'+locale.format('%.0f', now_xmr, grouping=True)

    context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 
    'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates}
    return render(request, 'monerojnet/marketcap.html', context)


def inflationreturn(request):
    count = 0
    xmr = []
    dash = []
    grin = []
    zcash = []
    btc = []
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0
    now_btc = 0
    inflation_xmr = []
    inflation_dash = []
    inflation_grin = []
    inflation_zcash = []
    inflation_btc = []

    lastxmrA = 0
    lastxmrB = 0

    count = 0
    coins = Coin.objects.order_by('date').filter(name='xmr')
    for coin in coins:
        count += 1
        if coin.priceusd and count > 30:
            now_xmr = coin.priceusd/5.01
            #correcao de um erro nos dados
            if 100/coin.inflation > 110 and now_xmr < 10:
                xmr.append(lastxmrA)
                inflation_xmr.append(lastxmrB)
            else:
                xmr.append(now_xmr)
                inflation_xmr.append(100/coin.inflation)
                lastxmrA = now_xmr
                lastxmrB = 100/coin.inflation

    count = 0
    coins = Coin.objects.order_by('date').filter(name='dash')
    for coin in coins:
        count += 1
        if coin.priceusd and count > 130:
            now_dash = coin.priceusd/14.7
            dash.append(now_dash)
            inflation_dash.append(100/coin.inflation)

    count = 0
    coins = Coin.objects.order_by('date').filter(name='grin')
    for coin in coins:
        count += 1
        if coin.priceusd and count > 155:
            now_grin = coin.priceusd/6.37
            grin.append(now_grin)
            inflation_grin.append(100/coin.inflation)

    count = 0
    coins = Coin.objects.order_by('date').filter(name='zec')
    for coin in coins:
        count += 1
        if coin.priceusd and count > 434:
            now_zcash = coin.priceusd/750
            zcash.append(now_zcash)
            inflation_zcash.append(100/coin.inflation)

    count = 0
    coins = Coin.objects.order_by('date').filter(name='btc')
    for coin in coins:
        count += 1
        if coin.priceusd and count > 325:
            now_btc = coin.priceusd/30
            btc.append(now_btc)
            inflation_btc.append(100/coin.inflation)

    now_dash = locale.format('%.2f', now_dash, grouping=True) 
    now_grin = locale.format('%.2f', now_grin, grouping=True)
    now_zcash = locale.format('%.2f', now_zcash, grouping=True)
    now_xmr = locale.format('%.2f', now_xmr, grouping=True)
    now_btc = locale.format('%.2f', now_btc, grouping=True)

    context = {'inflation_btc': inflation_btc,'inflation_xmr': inflation_xmr, 'inflation_dash': inflation_dash, 'inflation_grin': inflation_grin, 'inflation_zcash': inflation_zcash, 'now_xmr': now_xmr, 
    'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'now_btc': now_btc, 'btc': btc, 'xmr': xmr, 'dash': dash, 'zcash': zcash, 'grin': grin}
    return render(request, 'monerojnet/inflationreturn.html', context)

def bitcoin(request):
    dates = []
    dates3 = []
    dates4 = []
    btc = []
    xmr3 = []
    count1 = 0
    count3 = 0
    now_xmr = 0
    now_btc = 0

    coins_btc = Coin.objects.order_by('date').filter(name='btc')
    for coin_btc in coins_btc:
        if coin_btc.priceusd:
            if count1 > 325: #450
                btc.append(coin_btc.priceusd/30)
                now_btc = coin_btc.priceusd/30
            dates.append(count1)
            count1 += 1 #1.4
        elif count1 <= 325: #450
            continue
        else:
            btc.append('')

    coins_xmr = Coin.objects.order_by('date').filter(name='xmr')

    for coin_xmr in coins_xmr:
        if coin_xmr.priceusd:
            if count3 > 30:
                xmr3.append(coin_xmr.priceusd/5.01)
            dates4.append(count3)
            count3 += 0.82
        elif count3 <= 30:
            continue
        else:
            xmr3.append('')

    dates2 = []
    xmr2 = []
    btc2 = []

    for coin_btc in coins_btc:
        if coin_btc.priceusd:
            if coin_btc.priceusd/30 > 0.02:
                btc2.append(coin_btc.priceusd/30)
            else:
                btc2.append('')
        else:
            btc2.append('')
        dates2.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                if coin_xmr.priceusd/5.01 > 0.02:
                    xmr2.append(coin_xmr.priceusd/5.01)
                else:
                    xmr2.append('')
        else:
            xmr2.append('')

    now_btc = locale.format('%.2f', now_btc, grouping=True)
    now_xmr = locale.format('%.2f', now_xmr, grouping=True)

    context = {'btc': btc, 'xmr2': xmr2, 'btc2': btc2, 'xmr3': xmr3, 'dates': dates, 'dates2': dates2, 'dates3': dates3, 'dates4': dates4}
    return render(request, 'monerojnet/bitcoin.html', context)

def translin(request):
    symbol = 'xmr'
    transactions = []
    pricexmr = []
    dates = []
    now_transactions = 0
    maximum = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        if coin.transactions > 200:
            transactions.append(coin.transactions)
            now_transactions = coin.transactions
            if now_transactions > maximum:
                maximum = now_transactions            
        else:
            transactions.append('')
        
        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append('')

        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)
    
    now_transactions = int(now_transactions)
    maximum = int(maximum)

    context = {'transactions': transactions, 'dates': dates, 'maximum': maximum, 'now_transactions': now_transactions, 'pricexmr': pricexmr}
    return render(request, 'monerojnet/translin.html', context)

def percentage(request):
    symbol = 'xmr'
    transactions = []
    dates = []
    now_transactions = 0
    maximum = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        coins_aux = Coin.objects.order_by('date').filter(name='btc').filter(date=coin.date)
        if coin.transactions < 500:
            coin.transactions = 500
        if coins_aux:
            for coin_aux in coins_aux:
                if coin_aux.supply > 0 and coin_aux.transactions > 0:
                    now_transactions = 100*coin.transactions/coin_aux.transactions
                    if now_transactions > maximum:
                        maximum = now_transactions
                if now_transactions < 0.001:
                    now_transactions = 0.001
        transactions.append(now_transactions)
        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)
    
    now_transactions = locale.format('%.1f', now_transactions, grouping=True) + '%'
    maximum = locale.format('%.1f', maximum, grouping=True) + '%'

    context = {'transactions': transactions, 'dates': dates, 'now_transactions': now_transactions, 'maximum': maximum}
    return render(request, 'monerojnet/percentage.html', context)

def translog(request):
    symbol = 'xmr'
    transactions = []
    pricexmr = []
    dates = []
    now_transactions = 0
    maximum = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        if coin.transactions > 200:
            transactions.append(coin.transactions)
            now_transactions = coin.transactions
            if now_transactions > maximum:
                maximum = now_transactions            
        else:
            transactions.append('')
        
        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append('')

        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)
    
    now_transactions = int(now_transactions)
    maximum = int(maximum)

    context = {'transactions': transactions, 'dates': dates, 'maximum': maximum, 'now_transactions': now_transactions, 'pricexmr': pricexmr}
    return render(request, 'monerojnet/translog.html', context)

def hashrate(request):
    symbol = 'xmr'
    hashrate = []
    dates = []
    now_hashrate = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)
        if coin.hashrate > 0:
            now_hashrate = coin.hashrate
        hashrate.append(coin.hashrate)
    
    now_hashrate = locale.format('%.0f', now_hashrate, grouping=True)

    context = {'hashrate': hashrate, 'dates': dates, 'now_hashrate': now_hashrate}
    return render(request, 'monerojnet/hashrate.html', context)

def hashprice(request):
    symbol = 'xmr'
    hashrate = []
    dates = []
    buy = []
    sell = []
    now_hashrate = 0
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        if count > 50:
            buy.append(0.00000003)
            sell.append(0.00000100)
            coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
            dates.append(coin.date)
            if coin.hashrate > 0 and coin.priceusd > 0:
                now_hashrate = coin.priceusd/coin.hashrate
                hashrate.append(now_hashrate)
            else:
                hashrate.append('')
            new_color = 30*coin.pricebtc/(count*delta + v0)
            color.append(new_color)
        count += 1
    
    now_hashrate = locale.format('%.8f', now_hashrate, grouping=True)

    context = {'hashrate': hashrate, 'dates': dates, 'now_hashrate': now_hashrate, 'color': color, 'buy': buy, 'sell': sell}
    return render(request, 'monerojnet/hashprice.html', context)

def hashvsprice(request):
    symbol = 'xmr'
    hashrate = []
    prices = []
    dates = []
    now_hashrate = 0
    now_priceusd = 0
    now_pricebtc = 0
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        if count > 55:
            coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
            dates.append(coin.date)
            if coin.priceusd > 0:
                now_hashrate = coin.hashrate
                now_priceusd = coin.priceusd
                now_pricebtc = coin.pricebtc
                hashrate.append(now_hashrate)
                prices.append(now_priceusd)
            else:
                hashrate.append('')
                prices.append('')
            new_color = 30*coin.pricebtc/(count*delta + v0)
            color.append(new_color)
        count += 1
    
    now_hashrate = locale.format('%.0f', now_hashrate, grouping=True)
    now_priceusd = '$' + locale.format('%.2f', now_priceusd, grouping=True)
    now_pricebtc = locale.format('%.5f', now_pricebtc, grouping=True) + ' BTC'

    context = {'hashrate': hashrate, 'dates': dates, 'now_hashrate': now_hashrate, 'color': color, 'prices': prices, 'now_pricebtc': now_pricebtc, 'now_priceusd': now_priceusd}
    return render(request, 'monerojnet/hashvsprice.html', context)

def metcalfesats(request):
    symbol = 'xmr'
    color = []
    metcalfe = []
    prices = []
    dates = []
    now_metcalfe = 0
    now_price = 0
    maximum = 0
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        coins_aux = Coin.objects.order_by('date').filter(name='btc').filter(date=coin.date)
        if coin.transactions < 500:
            coin.transactions = 500
        if coins_aux:
            for coin_aux in coins_aux:
                if coin_aux.supply > 0 and coin_aux.transactions > 0:
                    now_metcalfe = coin.transactions*coin.supply/(coin_aux.supply*coin_aux.transactions)
                if now_metcalfe < 0.001:
                    now_metcalfe = 0.001
        metcalfe.append(now_metcalfe)
        if now_metcalfe > maximum:
            maximum = now_metcalfe
        if coin.pricebtc > 0:
            now_price = coin.pricebtc
        prices.append(coin.pricebtc)
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)
        count += 1
    
    now_price = locale.format('%.4f', now_price, grouping=True) + ' BTC'
    now_metcalfe = locale.format('%.4f', now_metcalfe, grouping=True) + ' BTC'
    maximum = locale.format('%.4f', maximum, grouping=True) + ' BTC'

    context = {'metcalfe': metcalfe, 'dates': dates, 'maximum': maximum, 'now_metcalfe': now_metcalfe, 'color': color, 'prices': prices, 'now_price': now_price}
    return render(request, 'monerojnet/metcalfesats.html', context)

def metcalfeusd(request):
    symbol = 'xmr'
    color = []
    metcalfe = []
    prices = []
    dates = []
    now_metcalfe = 0
    now_price = 0
    maximum = 0
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        coins_aux = Coin.objects.order_by('date').filter(name='btc').filter(date=coin.date)
        if coin.transactions < 500:
            coin.transactions = 500
        if coins_aux:
            for coin_aux in coins_aux:
                if coin_aux.supply > 0 and coin_aux.transactions > 0:
                    now_metcalfe = coin_aux.priceusd*coin.transactions*coin.supply/(coin_aux.supply*coin_aux.transactions)
                if now_metcalfe < 0.23:
                    now_metcalfe = 0.23
        metcalfe.append(now_metcalfe)
        if now_metcalfe > maximum:
            maximum = now_metcalfe
        if coin.priceusd > 0:
            now_price = coin.priceusd
        prices.append(now_price)
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)
        count += 1

    now_price = "$"+ locale.format('%.2f', now_price, grouping=True)
    now_metcalfe = "$"+ locale.format('%.2f', now_metcalfe, grouping=True)
    maximum = "$"+ locale.format('%.2f', maximum, grouping=True)

    context = {'metcalfe': metcalfe, 'dates': dates, 'maximum': maximum, 'now_metcalfe': now_metcalfe, 'color': color, 'prices': prices, 'now_price': now_price}
    return render(request, 'monerojnet/metcalfeusd.html', context)

def coins(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    supplyxmr = []
    supplybtc = []
    fsupplyxmr = []
    fsupplybtc = []
    dates = []
    now_xmr = 0
    now_btc = 0
    
    for coin_btc in coins_btc:
        supplybtc.append(int(coin_btc.supply))
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                supplyxmr.append(int(coin_xmr.supply))
                if coin_xmr.supply > now_xmr:
                    now_xmr = int(coin_xmr.supply)
        else:
            supplyxmr.append('')
        if coin_btc.supply > now_btc:
            now_btc = int(coin_btc.supply)
        fsupplyxmr.append('')
        fsupplybtc.append('')

    rewardbtc = 900
    supplybitcoin = coin_btc.supply
    supply = int(coin_xmr.supply)*10**12
    for i in range(365*(2060-2020)):
        supply = int(supply)
        reward = (2**64 -1 - supply) >> 19
        if reward < 0.6*(10**12):
            reward = 0.6*(10**12)
        supply += int(720*reward)
        fsupplyxmr.append(supply/(10**12))
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        supplybitcoin += rewardbtc
        if supplybitcoin > 21000000:
            supplybitcoin = 21000000
        fsupplybtc.append(supplybitcoin)
        date_aux2 = datetime.datetime.strftime(date_aux, '%Y-%m-%d')
        if date_aux2 == '2024-04-23':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2028-05-05':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2032-05-03':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2036-04-30':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2040-04-27':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2044-04-25':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2048-04-22':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2052-04-19':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2056-04-30':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2060-04-27':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2064-04-25':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2068-04-22':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2072-04-19':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2076-04-30':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2080-04-27':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2084-04-25':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2088-04-22':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2140-01-01':
            rewardbtc = 0
            supplybitcoin = 21000000
        supplyxmr.append('')
        supplybtc.append('')
        
    now_btc = locale.format('%.0f', now_btc, grouping=True)
    now_xmr = locale.format('%.0f', now_xmr, grouping=True)

    context = {'supplyxmr': supplyxmr, 'supplybtc': supplybtc, 'fsupplyxmr': fsupplyxmr, 'fsupplybtc': fsupplybtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/coins.html', context)

def dailyemission(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    emissionbtc = []
    emissionxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    high_btc = 0
    high_xmr = 0
    supplybtc = 0
    supplyxmr = 0
    valuebtc = 0
    valuexmr = 0

    for coin_btc in coins_btc:
        valuebtc = (coin_btc.supply - supplybtc)*coin_btc.priceusd
        if valuebtc < 1000:
            emissionbtc.append('')
        else:
            emissionbtc.append(valuebtc)
        supplybtc = coin_btc.supply
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                valuexmr = (coin_xmr.supply - supplyxmr)*coin_xmr.priceusd
                supplyxmr = coin_xmr.supply
                if valuexmr < 1000:
                    emissionxmr.append('')
                else:
                    emissionxmr.append(valuexmr)
                now_xmr = valuexmr
                if valuexmr > high_xmr:
                    high_xmr = valuexmr
        else:
            emissionxmr.append('')
        now_btc = valuebtc
        if valuebtc > high_btc:
            high_btc = int(valuebtc)

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        emissionxmr.append('')
        emissionbtc.append('')
        
    now_btc = "$" + locale.format('%.0f', now_btc, grouping=True)
    now_xmr = "$" + locale.format('%.0f', now_xmr, grouping=True)
    high_btc = "$" + locale.format('%.0f', high_btc, grouping=True)
    high_xmr = "$" + locale.format('%.0f', high_xmr, grouping=True)

    context = {'emissionxmr': emissionxmr, 'emissionbtc': emissionbtc, 'high_xmr': high_xmr, 'high_btc': high_btc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/dailyemission.html', context)

def extracoins(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    nsupply = []
    fsupply = []
    dates = []
    now_diff = 0
    
    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        coins_xmr = Coin.objects.order_by('date').filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                nsupply.append(int(- coin_xmr.supply + coin_btc.supply))
                now_diff = int(- coin_xmr.supply + coin_btc.supply)
        else:
            nsupply.append(int(coin_btc.supply))
        fsupply.append('')

    rewardbtc = 900
    supplybitcoin = coin_btc.supply
    supply = int(coin_xmr.supply)*10**12
    for i in range(365*(2060-2020)):
        supply = int(supply)
        reward = (2**64 -1 - supply) >> 19
        if reward < 0.6*(10**12):
            reward = 0.6*(10**12)
        supply += int(720*reward)
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        supplybitcoin += rewardbtc
        if supplybitcoin > 21000000:
            supplybitcoin = 21000000
        fsupply.append(-supply/(10**12) + supplybitcoin)
        date_aux2 = datetime.datetime.strftime(date_aux, '%Y-%m-%d')
        if date_aux2 == '2024-04-23':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2028-05-05':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2032-05-03':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2036-04-30':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2040-04-27':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2044-04-25':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2048-04-22':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2052-04-19':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2056-04-30':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2060-04-27':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2064-04-25':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2068-04-22':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2072-04-19':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2076-04-30':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2080-04-27':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2084-04-25':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2088-04-22':
            rewardbtc = rewardbtc/2
        if date_aux2 == '2140-01-01':
            rewardbtc = 0
            supplybitcoin = 21000000
        nsupply.append('')
        
    now_diff = locale.format('%.0f', now_diff, grouping=True)

    context = {'nsupply': nsupply, 'fsupply': fsupply, 'dates': dates, 'now_diff': now_diff}
    return render(request, 'monerojnet/extracoins.html', context)

def inflation(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    inflationxmr = []
    inflationbtc = []
    finflationxmr = []
    finflationbtc = []
    dates = []
    now_xmr = 999999
    now_btc = 999999
    
    for coin_btc in coins_btc:
        if float(coin_btc.inflation) > 0.1:
            inflationbtc.append(float(coin_btc.inflation))
            now_btc = float(coin_btc.inflation)
        else:
            inflationbtc.append('')
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        coins_xmr = Coin.objects.order_by('date').filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                inflationxmr.append(float(coin_xmr.inflation))
                now_xmr = float(coin_xmr.inflation)
        else:
            inflationxmr.append('')
        finflationxmr.append('')
        finflationbtc.append('')

    inflationbitcoin = 1.75
    supply = int(coin_xmr.supply)*10**12
    for i in range(2000):
        supply = int(supply)
        reward = (2**64 -1 - supply) >> 19
        if reward < 0.6*(10**12):
            reward = 0.6*(10**12)
        supply += int(720*reward)
        finflationxmr.append(100*reward*720*365/supply)
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        finflationbtc.append(inflationbitcoin)
        date_aux2 = datetime.datetime.strftime(date_aux, '%Y-%m-%d')
        if date_aux2 == '2024-04-23':
            inflationbitcoin = 0.65
        inflationxmr.append('')
        inflationbtc.append('')
        
    now_btc = locale.format('%.2f', now_btc, grouping=True) + '%'
    now_xmr = locale.format('%.2f', now_xmr, grouping=True) + '%'

    context = {'inflationxmr': inflationxmr, 'inflationbtc': inflationbtc, 'finflationxmr': finflationxmr, 'finflationbtc': finflationbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/inflation.html', context)

def compinflation(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    dates = []
    inflationxmr = []
    inflationdash = []
    inflationgrin = []
    inflationzcash = []
    inflationbtc = []
    now_xmr = 999999
    now_dash = 999999
    now_grin = 999999
    now_zcash = 999999
    now_btc = 999999
    count = 0
    
    for coin_btc in coins_btc:
        count += 1
        if coin_btc.inflation > 0.1:
            inflationbtc.append(coin_btc.inflation)
        else:
            inflationbtc.append('')
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        if count < 1750:
            inflationdash.append('')
            inflationxmr.append('')
        else:
            coins_dash = Coin.objects.filter(name='dash').filter(date=coin_btc.date)
            if coins_dash:
                for coin_dash in coins_dash:
                    if coin_dash.inflation > 0.1:
                        inflationdash.append(coin_dash.inflation)
                    else:
                        inflationdash.append('')
            else:
                inflationdash.append('')
            coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
            if coins_xmr:
                for coin_xmr in coins_xmr:
                    if coin_xmr.inflation > 0.1:
                        inflationxmr.append(coin_xmr.inflation)
                    else:
                        inflationxmr.append('')
            else:
                inflationxmr.append('')

        if count < 2800:
            inflationzcash.append('')
        else:
            coins_zcash = Coin.objects.filter(name='zec').filter(date=coin_btc.date)
            if coins_zcash:
                for coin_zcash in coins_zcash:
                    if coin_zcash.inflation > 0.1:
                        inflationzcash.append(coin_zcash.inflation)
                    else:
                        inflationzcash.append('')
            else:
                inflationzcash.append('')

        if count < 3600:
            inflationgrin.append('')
        else:
            coins_grin = Coin.objects.filter(name='grin').filter(date=coin_btc.date)
            if coins_grin:
                for coin_grin in coins_grin:
                    if coin_grin.inflation > 0.1:
                        inflationgrin.append(coin_grin.inflation)
                    else:
                        inflationgrin.append('')
            else:
                inflationgrin.append('')

    if count > 4300:
        now_grin = coin_grin.inflation
        now_zcash = coin_zcash.inflation
        now_btc = coin_btc.inflation
        now_xmr = coin_xmr.inflation
        now_dash = coin_dash.inflation
        
    now_dash = locale.format('%.2f', now_dash, grouping=True) + '%'
    now_grin = locale.format('%.2f', now_grin, grouping=True) + '%'
    now_zcash = locale.format('%.2f', now_zcash, grouping=True) + '%'
    now_xmr = locale.format('%.2f', now_xmr, grouping=True) + '%'
    now_btc = locale.format('%.2f', now_btc, grouping=True) + '%'

    context = {'inflationxmr': inflationxmr, 'inflationdash': inflationdash, 'inflationgrin': inflationgrin, 'inflationzcash': inflationzcash, 'inflationbtc': inflationbtc,
    'now_xmr': now_xmr, 'now_btc': now_btc, 'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/compinflation.html', context)

def sfmodel(request):
    check_new_social('Bitcoin')
    check_new_social('Monero')
    check_new_social('CryptoCurrency')
    symbol = 'btc'
    get_prices(symbol)
    symbol = 'dash'
    get_prices(symbol)
    symbol = 'grin'
    get_prices(symbol)
    symbol = 'zec'
    get_prices(symbol)
    symbol = 'xmr'
    get_prices(symbol)

    timevar = 1283
    symbol = 'xmr'
    now_price = 0
    now_sf = 0
    now_inflation = 0.001
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    maximum = 0
    supply = 0
    stock = 0.000001
    model = 0
    dates = []
    inflations = []
    circulations = []
    stock_to_flow = []
    projection = []
    color = []
    values = []

    sf_aux = 0
    skipped = 0
    start_inflation = 0
    count2 = 0
    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        values.append(coin.priceusd)
        date_aux1 = datetime.datetime.strptime('2017-12-29', '%Y-%m-%d')
        date_aux2 = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        date_aux2 = datetime.datetime.strptime(date_aux2, '%Y-%m-%d')
        if date_aux2 < date_aux1:
            lastprice = coin.priceusd
            start_inflation = coin.inflation
            current_inflation = start_inflation
            projection.append('')
            count2 = 0
        else:
            day = date_aux2 - timedelta(timevar)
            coin_aux1 = Coin.objects.filter(name=symbol).get(date=day)
            day = date_aux2 - timedelta(timevar+1)
            coin_aux2 = Coin.objects.filter(name=symbol).get(date=day)
            date_aux3 = datetime.datetime.strptime('2017-12-29', '%Y-%m-%d')
            
            if date_aux3 + timedelta(int(count2*2)) < datetime.datetime.strptime('2021-07-03', '%Y-%m-%d'):
                day = date_aux3 + timedelta(int(count2*2))
                coin_aux3 = Coin.objects.filter(name=symbol).get(date=day)
                if coin_aux3:
                    if (coin_aux3.inflation/current_inflation) > 1.2 or (coin_aux3.inflation/current_inflation) < 0.8:
                        coin_aux3.inflation = current_inflation
                    else:
                        current_inflation = coin_aux3.inflation
                supply2 = supply
            else:
                reward2 = (2**64 -1 - supply2) >> 19
                if reward2 < 0.6*(10**12):
                    reward2 = 0.6*(10**12)
                supply2 += int(720*reward2)
                current_inflation = 100*reward2*720*365/supply2
                
            if coin_aux1 and coin_aux2:
                lastprice += (coin_aux1.priceusd/coin_aux2.priceusd-1)*lastprice
                actualprice = lastprice*(math.sqrt(start_inflation/current_inflation))
                projection.append(actualprice)
                if skipped < 12:
                    projection.append(actualprice)
                else:
                    skipped = 0
            else:
                projection.append('')
            skipped += 1

        if coin.priceusd < 0.01:
            coin.priceusd = 0.01
        if coin.stocktoflow > sf_aux*2+250:
            coin.stocktoflow = sf_aux
        sf_aux = coin.stocktoflow
        if coin.stocktoflow < 0.1:
            coin.stocktoflow = 0.1
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        supply = int(coin.supply)*10**12
        stock_to_flow.append(coin.stocktoflow)
        count += 1
        count2 += 1

    count = 0
    for count in range(650):
        date_now = date.today() + timedelta(count)
        dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d'))
        reward = (2**64 -1 - supply) >> 19
        if reward < 0.6*(10**12):
            reward = 0.6*(10**12)
        supply += int(720*reward)
        inflation = 100*reward*720*365/supply
        inflations.append(inflation)
        circulations.append(supply)
        stock = (100/(inflation))**1.65
        stock_to_flow.append(stock)            

    now_price = "$"+ locale.format('%.2f', now_price, grouping=True)
    now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True)
    maximum = "$"+ locale.format('%.2f', maximum, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'inflations': inflations, 'circulations': circulations, 'stock_to_flow': stock_to_flow, 'projection': projection,
    'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color}
    return render(request, 'monerojnet/sfmodel.html', context)

def sfmodellin(request):
    symbol = 'xmr'
    now_price = 0
    now_sf = 0
    now_inflation = 0.001
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    maximum = 0
    supply = 0
    stock = 0.000001
    model = 0
    dates = []
    inflations = []
    circulations = []
    stock_to_flow = []
    color = []
    values = []

    sf_aux = 0 
    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        values.append(coin.priceusd)
        now_inflation = coin.inflation
        now_price = coin.priceusd
        now_sf = coin.stocktoflow
        lastprice = coin.priceusd
        if now_price > maximum:
            maximum = now_price
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        supply = int(coin.supply)*10**12
        if coin.stocktoflow > sf_aux*2+250:
            coin.stocktoflow = sf_aux
        sf_aux = coin.stocktoflow
        stock_to_flow.append(coin.stocktoflow)
        count += 1

    count = 0
    for count in range(1):
        date_now = date.today() + timedelta(count)
        dates.append(datetime.datetime.strftime(date_now, '%Y-%m-%d'))
        day = date_now - timedelta(1700)
        coin_aux1 = Coin.objects.filter(name=symbol).get(date=day)
        day = date_now - timedelta(1701)
        coin_aux2 = Coin.objects.filter(name=symbol).get(date=day)
        if coin_aux1 and coin_aux2:
            lastprice += (coin_aux1.priceusd/coin_aux2.priceusd-1)*lastprice*0.75
        reward = (2**64 -1 - supply) >> 19
        if reward < 0.6*(10**12):
            reward = 0.6*(  10**12)
        supply += int(720*reward)
        inflations.append(100*reward*720*365/supply)
        circulations.append(supply)
        stock = (100/(100*reward*720*365/supply))**1.65
        stock_to_flow.append(stock)            

    now_price = "$"+ locale.format('%.2f', now_price, grouping=True)
    now_sf = "$"+ locale.format('%.2f', now_sf, grouping=True)
    maximum = "$"+ locale.format('%.2f', maximum, grouping=True)
    now_inflation = locale.format('%.2f', now_inflation, grouping=True)+'%'

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'inflations': inflations, 'circulations': circulations, 'stock_to_flow': stock_to_flow,
    'now_price': now_price, 'now_inflation': now_inflation, 'now_sf': now_sf, 'color': color}
    return render(request, 'monerojnet/sfmodellin.html', context)

def sfmultiple(request):
    symbol = 'btc'
    get_prices(symbol)
    symbol = 'dash'
    get_prices(symbol)
    symbol = 'grin'
    get_prices(symbol)
    symbol = 'zec'
    get_prices(symbol)
    symbol = 'xmr'
    get_prices(symbol)

    symbol = 'xmr'
    now_sf = 0
    maximum = 0
    dates = []
    stock_to_flow = []
    values = []
    buy = []
    sell = []
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0

    sf_aux = 0 
    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        buy.append(1)
        sell.append(100)
        if coin.stocktoflow > sf_aux*2+250:
            coin.stocktoflow = sf_aux
        sf_aux = coin.stocktoflow
        if coin.priceusd < 1:
            coin.priceusd = 1
        if coin.stocktoflow != 0:
            now_sf = coin.supply*coin.priceusd/(coin.stocktoflow*1500000)
        stock_to_flow.append(now_sf)
        buy.append(1)
        sell.append(100)
        if now_sf > maximum:
            maximum = now_sf
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)
        count += 1  

    now_sf = locale.format('%.2f', now_sf, grouping=True)
    maximum = locale.format('%.2f', maximum, grouping=True)

    context = {'dates': dates, 'maximum': maximum, 'stock_to_flow': stock_to_flow, 'now_sf': now_sf, 'buy': buy, 'sell': sell, 'color': color}
    return render(request, 'monerojnet/sfmultiple.html', context)

def thermocap(request):
    symbol = 'xmr'
    dates = []
    values = []
    thermocap = []
    color = []
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    sf_aux = 0 
    supply = 0
    calorie = 1
    calories = []
    calories2 = []
    calories3 = []

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
        if coin.stocktoflow > sf_aux*2+250:
            coin.stocktoflow = sf_aux
        sf_aux = coin.stocktoflow
        values.append(coin.priceusd)
        new_color = 30*coin.pricebtc/(count*delta + v0)
        color.append(new_color)

        calorie += (coin.supply - supply)*coin.priceusd
        if calorie/(4200000*math.sqrt(coin.inflation)) < 0.1:
            calories.append('')
        else:
            calories.append(calorie/(4200000*math.sqrt(coin.inflation)))
        if calorie/(1000000*math.sqrt(coin.inflation)) < 0.1:
            calories2.append('')
        else:
            calories2.append(calorie/(1000000*math.sqrt(coin.inflation)))
        if 28*calorie/(2500000*math.sqrt(coin.inflation)) < 0.1:
            calories3.append('')
        else:
            calories3.append(28*calorie/(2500000*math.sqrt(coin.inflation)))
        temperature = coin.priceusd/calorie
        if temperature > 0.000004:
            temperature = 0.000004
        thermocap.append(temperature)
        supply = coin.supply
        count += 1  

    temperature = locale.format('%.2f', temperature, grouping=True)

    context = {'dates': dates, 'temperature': temperature, 'values': values, 'thermocap': thermocap, 'color': color, 'calories': calories,
    'calories2': calories2, 'calories3': calories3}
    return render(request, 'monerojnet/thermocap.html', context)

def sharpe(request):
    symbol = 'xmr'
    dates = []
    values = []
    color = []
    rocs = []
    sharpe = []
    v0 = 0.002
    delta = (0.015 - 0.002)/(6*365)
    count = 0
    price = 0
    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        new_color = 30*coin.pricebtc/(count*delta + v0)
        count += 1  
        if count % 7 == 0:
            if price == 0:
                if coin.priceusd > 0:
                    price = coin.priceusd
                    roc = 0
                else:
                    roc = 0
            else:
                roc = (coin.priceusd - price)/price
                price = coin.priceusd
            rocs.append(roc)
            dates.append(datetime.datetime.strftime(coin.date, '%Y-%m-%d'))
            values.append(coin.priceusd)
            color.append(new_color)
    
    n = 52
    median = pd.Series(rocs).rolling(window=n).mean().iloc[n-1:].values
    std = pd.Series(rocs).rolling(window=n).std().iloc[n-1:].values

    aux = list(map(truediv, median, std))
    for count in range(51):
        sharpe.append('')
    for item in aux:
        sharpe.append(item*math.sqrt(52))

    context = {'dates': dates, 'values': values, 'color': color, 'sharpe': sharpe}
    return render(request, 'monerojnet/sharpe.html', context)

def about(request):
    context = {}
    return render(request, 'monerojnet/about.html', context)

def transcost(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    costxmr2 = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        if coin_btc.transactions == 0:
            costbtc.append('')
        else:
            valuebtc = coin_btc.fee*coin_btc.priceusd/coin_btc.transactions
            if valuebtc < 0.0001:
                costbtc.append('')
            else:
                costbtc.append(valuebtc)
                now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                if coin_xmr.transactions == 0:
                    costxmr.append('')
                    costxmr2.append('')
                else:
                    valuexmr = coin_xmr.fee*coin_xmr.priceusd/coin_xmr.transactions
                    valuexmr2 = coin_xmr.fee*coin_btc.priceusd/coin_xmr.transactions
                    if valuexmr < 0.0001:
                        costxmr.append('')
                        costxmr2.append('')
                    else:
                        costxmr.append(valuexmr)
                        costxmr2.append(valuexmr2)
                        now_xmr = valuexmr
        else:
            costxmr.append('')
            costxmr2.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = "$" + locale.format('%.2f', now_btc, grouping=True)
    now_xmr = "$" + locale.format('%.2f', now_xmr, grouping=True)

    context = {'costxmr': costxmr, 'costxmr2': costxmr2, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/transcost.html', context)

def transcostntv(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        if coin_btc.transactions == 0:
            costbtc.append('')
        else:
            valuebtc = coin_btc.fee/coin_btc.transactions
            if valuebtc < 0.000001:
                costbtc.append('')
            else:
                costbtc.append(valuebtc)
                now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                if coin_xmr.transactions == 0:
                    costxmr.append('')
                else:
                    valuexmr = coin_xmr.fee/coin_xmr.transactions
                    if valuexmr < 0.000001:
                        costxmr.append('')
                    else:
                        costxmr.append(valuexmr)
                        now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.6f', now_btc, grouping=True)
    now_xmr = locale.format('%.6f', now_xmr, grouping=True)

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/transcostntv.html', context)

def minerrevcap(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        valuebtc = 365*100*coin_btc.revenue/coin_btc.supply
        if valuebtc < 0.0000001:
            costbtc.append('')
        else:
            costbtc.append(valuebtc)
            now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                valuexmr = 365*100*coin_xmr.revenue/coin_xmr.supply
                if valuexmr < 0.0000001:
                    costxmr.append('')
                else:
                    costxmr.append(valuexmr)
                    now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.2f', now_btc, grouping=True) + "%"
    now_xmr = locale.format('%.2f', now_xmr, grouping=True) + "%"

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/minerrevcap.html', context)

def minerrev(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        valuebtc = coin_btc.revenue*coin_btc.priceusd
        if valuebtc < 0.0001:
            costbtc.append('')
        else:
            costbtc.append(valuebtc)
            now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                valuexmr = coin_xmr.revenue*coin_xmr.priceusd
                if valuexmr < 0.0001:
                    costxmr.append('')
                else:
                    costxmr.append(valuexmr)
                    now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = "$" + locale.format('%.2f', now_btc, grouping=True)
    now_xmr = "$" + locale.format('%.2f', now_xmr, grouping=True)

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/minerrev.html', context)

def minerrevntv(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        valuebtc = coin_btc.revenue
        if valuebtc < 0.000001:
            costbtc.append('')
        else:
            costbtc.append(valuebtc)
            now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                valuexmr = coin_xmr.revenue
                if valuexmr < 0.000001:
                    costxmr.append('')
                else:
                    costxmr.append(valuexmr)
                    now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.2f', now_btc, grouping=True)
    now_xmr = locale.format('%.2f', now_xmr, grouping=True)

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/minerrevntv.html', context)

def minerfeesntv(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    supply_btc = 0
    supply_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        valuebtc = coin_btc.revenue - coin_btc.supply + supply_btc
        supply_btc = coin_btc.supply
        if valuebtc < 0.1:
            costbtc.append('')
        else:
            costbtc.append(valuebtc)
            now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                valuexmr = coin_xmr.revenue - coin_xmr.supply + supply_xmr
                supply_xmr = coin_xmr.supply
                if valuexmr < 0.1:
                    costxmr.append('')
                else:
                    costxmr.append(valuexmr)
                    now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.2f', now_btc, grouping=True)
    now_xmr = locale.format('%.2f', now_xmr, grouping=True)

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/minerfeesntv.html', context)

def minerfees(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    supply_btc = 0
    supply_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        valuebtc = (coin_btc.revenue - coin_btc.supply + supply_btc)*coin_btc.priceusd
        supply_btc = coin_btc.supply
        if valuebtc < 1:
            costbtc.append('')
        else:
            costbtc.append(valuebtc)
            now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                valuexmr = (coin_xmr.revenue - coin_xmr.supply + supply_xmr)*coin_xmr.priceusd
                supply_xmr = coin_xmr.supply
                if valuexmr < 1:
                    costxmr.append('')
                else:
                    costxmr.append(valuexmr)
                    now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.2f', now_btc, grouping=True)
    now_xmr = locale.format('%.2f', now_xmr, grouping=True)

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/minerfees.html', context)

def dailyemissionntv(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0
    supply_btc = 0
    supply_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        valuebtc = coin_btc.supply -  supply_btc
        if valuebtc < 0.000001:
            costbtc.append('')
        else:
            costbtc.append(valuebtc)
            now_btc = valuebtc
            supply_btc = coin_btc.supply
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                valuexmr = coin_xmr.supply - supply_xmr
                if valuexmr < 0.000001:
                    costxmr.append('')
                else:
                    costxmr.append(valuexmr)
                    now_xmr = valuexmr
                    supply_xmr = coin_xmr.supply
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.0f', now_btc, grouping=True)
    now_xmr = locale.format('%.0f', now_xmr, grouping=True)

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/dailyemissionntv.html', context)

def commit(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        if coin_btc.revenue*coin_btc.priceusd < 0.01:
            costbtc.append('')
        else:
            valuebtc = coin_btc.hashrate/(coin_btc.revenue*coin_btc.priceusd)
            costbtc.append(valuebtc)
            now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                if coin_xmr.revenue*coin_xmr.priceusd < 0.01:
                    costxmr.append('')
                else:
                    valuexmr = coin_xmr.hashrate/(coin_xmr.revenue*coin_xmr.priceusd)
                    costxmr.append(valuexmr)
                    now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.2f', now_btc, grouping=True) + " hashs / dollar"
    now_xmr = locale.format('%.2f', now_xmr, grouping=True) + " hashs / dollar"

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/commit.html', context)

def commitntv(request):
    coins_btc = Coin.objects.order_by('date').filter(name='btc')

    costbtc = []
    costxmr = []
    dates = []
    now_btc = 0
    now_xmr = 0

    for coin_btc in coins_btc:
        dates.append(datetime.datetime.strftime(coin_btc.date, '%Y-%m-%d'))
        if coin_btc.revenue  < 0.01:
            costbtc.append('')
        else:
            valuebtc = coin_btc.hashrate/coin_btc.revenue
            if valuebtc < 0.001:
                costbtc.append('')
            else:
                costbtc.append(valuebtc)
            now_btc = valuebtc
        coins_xmr = Coin.objects.filter(name='xmr').filter(date=coin_btc.date)
        if coins_xmr:
            for coin_xmr in coins_xmr:
                if coin_xmr.revenue < 0.01:
                    costxmr.append('')
                else:
                    valuexmr = coin_xmr.hashrate/coin_xmr.revenue
                    if valuexmr < 0.001:
                        costxmr.append('')
                    else:
                        costxmr.append(valuexmr)
                    now_xmr = valuexmr
        else:
            costxmr.append('')

    for i in range(500):
        date_aux = coin_btc.date + timedelta(i)
        dates.append(datetime.datetime.strftime(date_aux, '%Y-%m-%d'))
        costbtc.append('')
        costxmr.append('')
        
    now_btc = locale.format('%.0f', now_btc, grouping=True) + " hashs / btc"
    now_xmr = locale.format('%.0f', now_xmr, grouping=True) + " hashs / xmr"

    context = {'costxmr': costxmr, 'costbtc': costbtc, 'now_xmr': now_xmr, 'now_btc': now_btc, 'dates': dates}
    return render(request, 'monerojnet/commitntv.html', context)

def competitorssats(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    count = 0
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0

    count = 0
    coins_xmr = Coin.objects.order_by('date').filter(name='xmr')
    for coin_xmr in coins_xmr:
        if coin_xmr.pricebtc:
            if count > 32:
                xmr.append(coin_xmr.pricebtc/0.0058)
                now_xmr = coin_xmr.pricebtc/0.0058
            dates.append(count)
            count += 1
        elif count <= 63:
            continue
        else:
            xmr.append('')

    count = 0
    coins_dash = Coin.objects.order_by('date').filter(name='dash')
    for coin_dash in coins_dash:
        count += 1
        if coin_dash.pricebtc and count > 130:
            dash.append(coin_dash.pricebtc/0.02)
            now_dash = coin_dash.pricebtc/0.02
        elif count <= 130:
            continue
        else:
            dash.append('')
        dates.append(count)

    count = 0
    coins_grin = Coin.objects.order_by('date').filter(name='grin')
    for coin_grin in coins_grin:
        count += 1
        if coin_grin.pricebtc and count > 155:
            grin.append(coin_grin.pricebtc/0.000513)
            now_grin = coin_grin.pricebtc/0.000513
        elif count <= 155:
            continue
        else:
            grin.append('')
        dates.append(count)

    count = 0
    coins_zcash = Coin.objects.order_by('date').filter(name='zec')
    for coin_zcash in coins_zcash:
        count += 1
        if coin_zcash.pricebtc and count > 434:
            zcash.append(coin_zcash.pricebtc/0.05)
            now_zcash = coin_zcash.pricebtc/0.05
        elif count <= 434:
            continue
        else:
            zcash.append('')
        dates.append(count)

    now_dash = locale.format('%.3f', now_dash, grouping=True) 
    now_grin = locale.format('%.3f', now_grin, grouping=True)
    now_zcash = locale.format('%.3f', now_zcash, grouping=True)
    now_xmr = locale.format('%.3f', now_xmr, grouping=True)

    context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 
    'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates}
    return render(request, 'monerojnet/competitorssats.html', context)

def competitorssatslin(request):
    dates = []
    xmr = []
    dash = []
    grin = []
    zcash = []
    count = 0
    now_xmr = 0
    now_dash = 0
    now_grin = 0
    now_zcash = 0

    count = 0
    coins_xmr = Coin.objects.order_by('date').filter(name='xmr')
    for coin_xmr in coins_xmr:
        if coin_xmr.pricebtc:
            if count > 32:
                xmr.append(coin_xmr.pricebtc/0.0058)
                now_xmr = coin_xmr.pricebtc/0.0058
            dates.append(count)
            count += 1
        elif count <= 63:
            continue
        else:
            xmr.append('')

    count = 0
    coins_dash = Coin.objects.order_by('date').filter(name='dash')
    for coin_dash in coins_dash:
        count += 1
        if coin_dash.pricebtc and count > 130:
            dash.append(coin_dash.pricebtc/0.02)
            now_dash = coin_dash.pricebtc/0.02
        elif count <= 130:
            continue
        else:
            dash.append('')
        dates.append(count)

    count = 0
    coins_grin = Coin.objects.order_by('date').filter(name='grin')
    for coin_grin in coins_grin:
        count += 1
        if coin_grin.pricebtc and count > 155:
            grin.append(coin_grin.pricebtc/0.000513)
            now_grin = coin_grin.pricebtc/0.000513
        elif count <= 155:
            continue
        else:
            grin.append('')
        dates.append(count)

    count = 0
    coins_zcash = Coin.objects.order_by('date').filter(name='zec')
    for coin_zcash in coins_zcash:
        count += 1
        if coin_zcash.pricebtc and count > 434:
            zcash.append(coin_zcash.pricebtc/0.05)
            now_zcash = coin_zcash.pricebtc/0.05
        elif count <= 434:
            continue
        else:
            zcash.append('')
        dates.append(count)

    now_dash = locale.format('%.3f', now_dash, grouping=True) 
    now_grin = locale.format('%.3f', now_grin, grouping=True)
    now_zcash = locale.format('%.3f', now_zcash, grouping=True)
    now_xmr = locale.format('%.3f', now_xmr, grouping=True)

    context = {'xmr': xmr, 'dash': dash, 'grin': grin, 'zcash': zcash, 'now_xmr': now_xmr, 
    'now_dash': now_dash, 'now_grin': now_grin, 'now_zcash': now_zcash, 'dates': dates}
    return render(request, 'monerojnet/competitorssatslin.html', context)

def dread_subscribers(request):
    dates = []
    data1 = []
    data2 = []
    now_xmr = 0
    now_btc = 0

    gc = pygsheets.authorize(service_file='service_account_credentials.json')
    sh = gc.open('zcash_bitcoin')
    wks = sh.worksheet_by_title('Sheet6')
    
    values_mat = wks.get_values(start=(3,1), end=(99,3), returnas='matrix')
    print(len(values_mat))

    for k in range(0,len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            if not(value1) or not(value2):
                break
            else:
                dates.append(date)
                data1.append(int(value1))
                data2.append(int(value2))
                now_xmr = int(value2)
                now_btc = int(value1)
        else:
            break
        
    dominance = 100*int(value2)/(int(value2)+int(value1))

    now_btc = locale.format('%.0f', now_btc, grouping=True)
    now_xmr = locale.format('%.0f', now_xmr, grouping=True)
    dominance = locale.format('%.2f', dominance, grouping=True)

    context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr, 'data1': data1, "data2": data2, "dominance": dominance}
    return render(request, 'monerojnet/dread_subscribers.html', context)

def coincards(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    now_xmr = 0
    now_btc = 0

    gc = pygsheets.authorize(service_file='service_account_credentials.json')
    sh = gc.open('zcash_bitcoin')
    wks = sh.worksheet_by_title('Sheet2')
    
    values_mat = wks.get_values(start=(3,1), end=(99,5), returnas='matrix')
    print(len(values_mat))

    for k in range(0,len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            if not(value1) or not(value2) or not(value3) or not(value4):
                break
            else:
                dates.append(date)
                data1.append(float(value1.replace(',','.')))
                data2.append(float(value2.replace(',','.')))
                data3.append(float(value3.replace(',','.')))
                data4.append(float(value4.replace(',','.')))
                now_btc = float(value1.replace(',','.'))
                now_xmr = float(value2.replace(',','.'))
                now_eth = float(value3.replace(',','.'))
                now_others = float(value4.replace(',','.'))
        else:
            break

    now_btc = locale.format('%.1f', now_btc, grouping=True)
    now_xmr = locale.format('%.1f', now_xmr, grouping=True)
    now_eth = locale.format('%.1f', now_eth, grouping=True)
    now_others = locale.format('%.1f', now_others, grouping=True)

    context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr,  'now_eth': now_eth, 'now_others': now_others, 'data1': data1, "data2": data2, "data3": data3, "data4": data4}
    return render(request, 'monerojnet/coincards.html', context)

def merchants(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    data5 = []
    data6 = []
    data7 = []
    now_xmr = 0
    now_btc = 0
    now_eth = 0

    gc = pygsheets.authorize(service_file='service_account_credentials.json')
    sh = gc.open('zcash_bitcoin')
    wks = sh.worksheet_by_title('Sheet3')
    
    values_mat = wks.get_values(start=(3,1), end=(99,8), returnas='matrix')
    print(len(values_mat))

    for k in range(0,len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            value5 = values_mat[k][5]
            value6 = values_mat[k][6]
            value7 = values_mat[k][7]
            if not(value1) or not(value2) or not(value3) or not(value4) or not(value5) or not(value6) or not(value7):
                break
            else:
                dates.append(date)
                data1.append(int(value1))
                data2.append(int(value2))
                data3.append(int(value3))
                data4.append(int(value4))
                data5.append(int(value5))
                data6.append(int(value6))
                data7.append(int(value7))
                now_btc = int(value1)
                now_xmr = int(value2)
                now_eth = int(value3)
        else:
            break

    now_btc = locale.format('%.0f', now_btc, grouping=True)
    now_xmr = locale.format('%.0f', now_xmr, grouping=True)
    now_eth = locale.format('%.0f', now_eth, grouping=True)

    context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr,  'now_eth': now_eth, 'data1': data1, "data2": data2, "data3": data3, "data4": data4, "data5": data5, "data6": data6, "data7": data7}
    return render(request, 'monerojnet/merchants.html', context)

def merchants_increase(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    data5 = []
    data6 = []
    data7 = []
    now_xmr = 0
    now_btc = 0
    now_eth = 0

    gc = pygsheets.authorize(service_file='service_account_credentials.json')
    sh = gc.open('zcash_bitcoin')
    wks = sh.worksheet_by_title('Sheet4')
    
    values_mat = wks.get_values(start=(3,1), end=(99,8), returnas='matrix')
    print(len(values_mat))

    for k in range(0,len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            value5 = values_mat[k][5]
            value6 = values_mat[k][6]
            value7 = values_mat[k][7]
            if not(value1) or not(value2) or not(value3) or not(value4) or not(value5) or not(value6) or not(value7):
                break
            else:
                dates.append(date)
                data1.append(int(value1))
                data2.append(int(value2))
                data3.append(int(value3))
                data4.append(int(value4))
                data5.append(int(value5))
                data6.append(int(value6))
                data7.append(int(value7))
                now_btc = int(value1)
                now_xmr = int(value2)
                now_eth = int(value3)
        else:
            break

    now_btc = locale.format('%.0f', now_btc, grouping=True)
    now_xmr = locale.format('%.0f', now_xmr, grouping=True)
    now_eth = locale.format('%.0f', now_eth, grouping=True)

    context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr,  'now_eth': now_eth, 'data1': data1, "data2": data2, "data3": data3, "data4": data4, "data5": data5, "data6": data6, "data7": data7}
    return render(request, 'monerojnet/merchants_increase.html', context)

def merchants_percentage(request):
    dates = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    data5 = []
    data6 = []
    data7 = []
    now_xmr = 0
    now_btc = 0
    now_eth = 0
    
    gc = pygsheets.authorize(service_file='service_account_credentials.json')
    sh = gc.open('zcash_bitcoin')
    wks = sh.worksheet_by_title('Sheet5')
    
    values_mat = wks.get_values(start=(3,1), end=(99,8), returnas='matrix')
    print(len(values_mat))

    for k in range(0,len(values_mat)):
        if values_mat[k][0] and values_mat[k][2]:
            date = values_mat[k][0]
            value1 = values_mat[k][1]
            value2 = values_mat[k][2]
            value3 = values_mat[k][3]
            value4 = values_mat[k][4]
            value5 = values_mat[k][5]
            value6 = values_mat[k][6]
            value7 = values_mat[k][7]
            if not(value1) or not(value2) or not(value3) or not(value4) or not(value5) or not(value6) or not(value7):
                break
            else:
                dates.append(date)
                data1.append(float(value1.replace(',', '.')))
                data2.append(float(value2.replace(',', '.')))
                data3.append(float(value3.replace(',', '.')))
                data4.append(float(value4.replace(',', '.')))
                data5.append(float(value5.replace(',', '.')))
                data6.append(float(value6.replace(',', '.')))
                data7.append(float(value7.replace(',', '.')))
                now_btc = float(value1.replace(',', '.'))
                now_xmr = float(value2.replace(',', '.'))
                now_eth = float(value3.replace(',', '.'))
        else:
            break

    now_btc = locale.format('%.1f', now_btc, grouping=True)
    now_xmr = locale.format('%.1f', now_xmr, grouping=True)
    now_eth = locale.format('%.1f', now_eth, grouping=True)

    context = {'dates': dates, 'now_btc': now_btc, 'now_xmr': now_xmr,  'now_eth': now_eth, 'data1': data1, "data2": data2, "data3": data3, "data4": data4, "data5": data5, "data6": data6, "data7": data7}
    return render(request, 'monerojnet/merchants_percentage.html', context)

def dominance(request):
    symbol = 'xmr'
    values = []
    pricexmr = []
    dates = []
    now_value = 0
    maximum = 0

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        try:
            dominance = Dominance.objects.get(date=coin.date)
            if dominance.dominance > 0:
                values.append(dominance.dominance)
                now_value = dominance.dominance
                if now_value > maximum:
                    maximum = now_value            
            else:
                values.append('')
        except:
            values.append('')

        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append('')

        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)

    now_value = locale.format('%.2f', now_value, grouping=True)
    maximum = locale.format('%.2f', maximum, grouping=True)

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_value': now_value, 'pricexmr': pricexmr}
    return render(request, 'monerojnet/dominance.html', context)

def rank(request):
    symbol = 'xmr'
    values = []
    pricexmr = []
    dates = []
    now_value = 25
    maximum = 100

    coins = Coin.objects.order_by('date').filter(name=symbol)
    for coin in coins:
        try:
            rank = Rank.objects.get(date=coin.date)
            if rank.rank > 0:
                values.append(rank.rank)
                now_value = rank.rank
                if now_value < maximum:
                    maximum = now_value            
            else:
                values.append(now_value)
        except:
            values.append(now_value)

        if coin.priceusd > 0.001:
            pricexmr.append(coin.priceusd)
        else:
            pricexmr.append('')

        coin.date = datetime.datetime.strftime(coin.date, '%Y-%m-%d')
        dates.append(coin.date)

    if now_value == 1:
        now_value = locale.format('%.0f', now_value, grouping=True) + 'st'
    if now_value == 2:
        now_value = locale.format('%.0f', now_value, grouping=True) + 'nd'
    if now_value == 3:
        now_value = locale.format('%.0f', now_value, grouping=True) + 'rd'
    if now_value > 3:
        now_value = locale.format('%.0f', now_value, grouping=True) + 'th'
    if maximum == 1:
        maximum = locale.format('%.0f', maximum, grouping=True) + 'st'
    if maximum == 2:
        maximum = locale.format('%.0f', maximum, grouping=True) + 'nd'
    if maximum == 3:
        maximum = locale.format('%.0f', maximum, grouping=True) + 'rd'
    if maximum > 3:
        maximum = locale.format('%.0f', maximum, grouping=True) + 'th'

    context = {'values': values, 'dates': dates, 'maximum': maximum, 'now_value': now_value, 'pricexmr': pricexmr}
    return render(request, 'monerojnet/rank.html', context)


#########################################
######## Functions
#########################################

# Get prices
def get_prices(symbol):
    inflation = 0
    priceusd = 0
    hashrate = 0
    pricebtc = 0
    transactions = 0
    fee = 0
    revenue = 0
    now = datetime.datetime.now()
    current_time = int(now.strftime("%H"))
    if current_time >= 5:
        print('Hour > 5')
        day1 = date.today() - timedelta(2)
        coins = Coin.objects.filter(name=symbol).filter(date=day1)
        if coins:
            for coin in coins:
                inflation = coin.inflation
                priceusd = coin.priceusd
                hashrate = coin.hashrate
                pricebtc = coin.pricebtc
                transactions = coin.transactions
                fee = coin.fee
                revenue = coin.revenue
        getthem = False
        day1 = date.today() - timedelta(1)
        coins = Coin.objects.filter(name=symbol).filter(date=day1)
        if coins:
            for coin in coins:
                if coin.inflation == inflation and coin.priceusd == priceusd and coin.hashrate == hashrate:
                    print('Update')
                    coin.delete()
                    getthem = True
        else:
            getthem = True

        if getthem:
            test = True
            count = 1
            request = ''
            while test: 
                print('page ' + str(count))
                count += 1
                response = requests.get(request)
                data = json.loads(response.text)
                data_aux = data['data']
                deltasupply = 0
                supply = 0
                first = True
                for item in data_aux:
                    day, hour = str(item['time']).split('T')
                    day = datetime.datetime.strptime(day, '%Y-%m-%d')
                    day = datetime.datetime.strftime(day, '%Y-%m-%d')
                    coin = Coin.objects.filter(name=symbol).filter(date=day)
                    if not(coin):
                        if item['SplyCur'] != None:
                            if float(item['SplyCur']) >= 1:
                                coin = Coin()
                                coin.name = symbol
                                coin.date = day
                                try:
                                    coin.priceusd = float(item['PriceUSD'])
                                except:
                                    coin.priceusd = priceusd
                                try:
                                    coin.hashrate = float(item['HashRate'])
                                except:
                                    coin.hashrate = hashrate
                                try:
                                    coin.fee = float(item['FeeTotNtv'])
                                except:
                                    coin.fee = fee
                                try:
                                    coin.revenue = float(item['RevNtv'])
                                except:
                                    coin.revenue = revenue
                                try:
                                    coin.pricebtc = float(item['PriceBTC'])
                                except:
                                    coin.pricebtc = pricebtc
                                try:
                                    coin.inflation = float(item['IssContPctAnn'])
                                except:
                                    coin.inflation = inflation
                                try:
                                    coin.transactions = float(item['TxCnt'])
                                except:
                                    coin.transactions = transactions
                                try:
                                    if first:
                                        coin.supply = float(item['SplyCur'])
                                        supply = coin.supply
                                        deltasupply = 0
                                        first = False
                                    else:
                                        coin.supply = float(item['SplyCur'])
                                        deltasupply = abs(supply - coin.supply)
                                        supply = coin.supply
                                    if supply <= (deltasupply*20):
                                        test = False
                                except:
                                    coin.supply = 0
                                try:
                                    coin.stocktoflow = (100/coin.inflation)**1.65
                                except:
                                    coin.stocktoflow = 0
                                coin.save()
                            else:
                                test = False
                        else:
                            day1 = datetime.datetime.strptime(day, '%Y-%m-%d') + timedelta(1)
                            day2 = date.today()
                            day2 = datetime.datetime.strftime(day2, '%Y-%m-%d')
                            day2 = datetime.datetime.strptime(day2, '%Y-%m-%d')
                            if str(day) == str(day2) or str(day1) == str(day2):
                                print('today')
                            else:
                                test = False
                    else:
                        test = False
                    print('supply = ' + str(supply) + ' ---- deltasupply = ' + str(deltasupply*20) + ' -------- test = ' + str(test))
                if test:
                    request = data['next_page_url']
                    print(request)
    return(True)