class Tags(AutoSlugifyOnSaveModel):
TAG_TYPES = (
('T', 'Twitter'),
('A', 'Article tag collector'),
('D', 'Database tag collector'),
('G', 'Google Adwords'),
)
if not settings.EXISTING_SITE:
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=30,
verbose_name=T("Tag"),
unique=True)
else:
title = models.CharField(max_length=30,
verbose_name=T("Tag"),
primary_key=True)
slug = models.CharField(max_length=30, blank=True, null=True)
active = models.BooleanField(default=0)
tag_type = models.CharField(
max_length=10,
verbose_name=T("Tag type"),
choices=TAG_TYPES,
default='A',
)
def __unicode__(self):
return '%s' % (self.title)
def __str__(self):
return '%s' % (self.title)
class Category(AutoSlugifyOnSaveModel):
if not settings.EXISTING_SITE:
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=40,
verbose_name=T("Categoery"),
unique=True)
else:
title = models.CharField(max_length=40,
verbose_name=T("Categoery"),
primary_key=True)
slug = models.CharField(max_length=40, blank=True, null=True)
thumbnail = models.ImageField(upload_to="uploads/",
blank=True,
null=True,
verbose_name=T("Image thumbnail"),
height_field=None,
width_field=None)
class Meta:
ordering = ('title', )
def __unicode__(self):
return '%s' % (self.title)
def __str__(self):
return '%s' % (self.title)
def wrapper(bot: tg.Bot, up: tg.Update, *args, **kwargs):
chat_data = kwargs.pop("chat_data")
cmd_args = kwargs.pop("args", None)
if cmd_args is None:
tracking_number = up.effective_message.text.strip()
else:
tracking_number = " ".join(cmd_args).strip()
if not tracking_number:
up.effective_message.reply_text(
T("Please enter a tracking number:\n\n(Case insensitive)"))
return fn.__name__
try:
chat_data["appointment"] = Appointment.objects.get(
tracking_number__iexact=tracking_number, is_cancelled=False)
except Appointment.DoesNotExist:
up.effective_message.reply_text(
T(f"You entered an invalid tracking number.\n\n"
"Please enter a valid tracking number:"),
parse_mode="Markdown",
)
return fn.__name__
else:
return fn(bot, up, *args, **kwargs, chat_data=chat_data)
def recv_new_time_slot(_, up: tg.Update, chat_data: dict):
query: tg.CallbackQuery = up.callback_query
weekday_id, time_slot_pk = query.data[len(recv_new_time_slot.__name__
):].split(":")
appointment = chat_data["appointment"]
appointment.weekday = weekday_id
appointment.time_slot = TimeSlot.objects.get(pk=time_slot_pk)
try:
appointment.validate_time_slot()
appointment.validate_weekday()
except ValidationError:
try:
up.effective_message.edit_text(
T("You entered an invalid Time slot.\n"
"Please choose a valid time slot."),
reply_markup=util.get_time_slot_keyboard(
appointment.pin_code,
callback_pattern=recv_new_time_slot.__name__),
)
except tg.error.BadRequest:
query.answer()
else:
appointment.save()
up.effective_message.edit_text(text=T(
f"Appointment rescheduled for {util.get_pretty_time_slot(appointment.weekday, appointment.time_slot)}."
))
class NetworkSite(models.Model):
id = models.AutoField(primary_key=True)
path = models.CharField(max_length=250,
verbose_name=T("Path to projects"),
default="/home")
folder_name = models.CharField(max_length=50,
verbose_name=T("Project folder name"))
def show_list(_, up: tg.Update):
appointments = util.get_user(up).appointment_set.exclude(is_cancelled=True)
if not appointments.exists():
up.effective_message.reply_text(
T("You haven't booked any appointments yet!\n"
"Use /book to book a service appointment."))
return
up.effective_message.reply_text(
T("Here is a list of all your previous appointments."))
for appointment in appointments:
reply_markup = tg.InlineKeyboardMarkup([[
tg.InlineKeyboardButton(
text=T("Cancel"),
callback_data=
f"{hyperlink.__name__}{cancel.__name__}:{appointment.pk}",
),
tg.InlineKeyboardButton(
text=T("Check details"),
callback_data=
f"{hyperlink.__name__}{check.__name__}:{appointment.pk}",
),
tg.InlineKeyboardButton(
text=T("Reschedule"),
callback_data=
f"{hyperlink.__name__}{schedule.__name__}:{appointment.pk}",
),
]])
up.effective_message.reply_text(
text=appointment.short_detail_markup,
reply_markup=reply_markup,
parse_mode="Markdown",
)
class ExpenseCategory(models.Model):
title = models.CharField(max_length=120, verbose_name=T("Expense category"), primary_key=True)
description = models.TextField(blank=True, null=True, verbose_name=T("Category description"))
parent = models.ForeignKey('self', verbose_name=T("Parent category"), default=None, blank=True, null=True)
def __str__(self):
return u'%s' %(self.title)
def recv_phone_number(_, up: tg.Update, chat_data: dict):
message: tg.Message = up.effective_message
user = util.get_user(up)
try:
user.phone_number = message.contact.phone_number
except AttributeError:
user.phone_number = message.text
try:
user.clean_fields()
except ValidationError:
util.request_phone_number(
up,
T("You entered an invalid Phone Number.\n"
"Please enter a valid Phone Number."),
)
return recv_phone_number.__name__
chat_data["user"] = user
up.effective_message.reply_text(
text=T(
"Thanks for the Phone Number.\n"
"One last thing, can you please provide me with your Email Address?"
),
reply_markup=tg.replykeyboardremove.ReplyKeyboardRemove(),
)
return recv_email.__name__
class CUser(models.Model):
name = models.CharField(max_length=25, null=True, blank=True)
nickname = models.CharField(max_length=25, null=True, blank=True)
email = models.EmailField(max_length=150, verbose_name=T("Email"), primary_key=True)
location = models.CharField(max_length=255, verbose_name=T("Location"), blank=True, null=True)
description = models.CharField(max_length=255, verbose_name=T("Description"), blank=True, null=True)
def __str__(self):
return u'%s' %(self.nickname)
class PortfolioStrats(models.Model):
id = models.BigAutoField(primary_key=True)
user = models.ForeignKey(QtraUser, verbose_name=T("User"))
strategy = models.OneToOneField(Portfolios, verbose_name=T("Strategy"))
def __unicode__(self):
return '%s %s' % (self.id, self.user)
def __str__(self):
return '%s %s' % (self.id, self.user)
class TwitsByTag(models.Model):
tweet_id = models.BigIntegerField(primary_key=True,
verbose_name=T("Tweet ID"))
content = models.CharField(max_length=140, verbose_name=T("Tweet text"))
twitter_handle = models.CharField(max_length=40,
verbose_name=T("Twitter handle"))
screen_name = models.CharField(max_length=30,
verbose_name=T("Twitter screen name"))
profile_image = models.CharField(
max_length=250,
blank=True,
null=True,
verbose_name=T("Twitter profile image URL"))
date = models.DateTimeField(verbose_name=T("Date"))
hashtags = models.CharField(max_length=140,
verbose_name=T("Hashtags"),
blank=True,
null=True)
tags = models.ManyToManyField(Tags, blank=True, verbose_name=T("Tags"))
by_tag = models.CharField(max_length=40,
verbose_name=T("What tag is used to query it"))
class Meta:
ordering = ('date', )
def __unicode__(self):
return '(%s) %s %s' % (self.content, self.screen_name, self.hashtags)
def __str__(self):
return '(%s) %s %s' % (self.content, self.screen_name, self.hashtags)
def recv_time_slot(_, up: tg.Update, chat_data: dict):
query: tg.CallbackQuery = up.callback_query
weekday_id, time_slot_pk = query.data.split(":")
appointment = chat_data["appointment"]
appointment.weekday = weekday_id
appointment.time_slot = TimeSlot.objects.get(pk=time_slot_pk)
try:
appointment.validate_time_slot()
appointment.validate_weekday()
except ValidationError:
try:
up.effective_message.edit_text(
T("You entered an invalid time slot.\n"
"Please choose a valid time slot."),
reply_markup=util.get_time_slot_keyboard(appointment.pin_code),
)
except tg.error.BadRequest:
query.answer()
return recv_time_slot.__name__
appointment.save()
reply_markup = tg.InlineKeyboardMarkup([[
tg.InlineKeyboardButton(
text=T("Cancel"),
callback_data=
f"{hyperlink.__name__}{cancel.__name__}:{appointment.pk}",
),
tg.InlineKeyboardButton(
text=T("Check details"),
callback_data=
f"{hyperlink.__name__}{check.__name__}:{appointment.pk}",
),
tg.InlineKeyboardButton(
text=T("Reschedule"),
callback_data=
f"{hyperlink.__name__}{schedule.__name__}:{appointment.pk}",
),
]])
up.effective_message.reply_text(
T(f"Appointment scheduled for {util.get_pretty_time_slot(appointment.weekday, appointment.time_slot)}.\n\n"
f"Tracking No. for this appointment:\n\n"
f"`{appointment.tracking_number}`\n\n"
f"(Long press to copy)"),
parse_mode="Markdown",
reply_markup=reply_markup,
)
return ConversationHandler.END
class Accounts(models.Model):
id = models.BigAutoField(primary_key=True)
user = models.ForeignKey(CUser, on_delete=models.CASCADE, verbose_name=T("User"))
title = models.CharField(max_length=120, verbose_name=T("Account name"))
currency = models.ForeignKey(Currencies, verbose_name=T("Currency"))
class Meta:
unique_together = ("user", "title", "currency")
def __str__(self):
return u'%s' %(self.title)
class Post(models.Model):
id = models.BigAutoField(primary_key=True)
title = models.CharField(max_length=150, verbose_name=T("Title"))
date_time = models.DateTimeField(verbose_name=T("Date"))
content = models.TextField(verbose_name=T("Content"))
def __unicode__(self):
return '%s' % (self.title)
def __str__(self):
return '%s' % (self.title)
class TermLinks(models.Model):
LINK_STATUSES = (
('T', 'Term link'),
('U', 'Unknown'),
('A', 'Article in db'),
)
link = models.URLField(verbose_name=T("URL"), primary_key=True)
status_parsed = models.CharField(max_length=5,
verbose_name=T("Status"),
choices=LINK_STATUSES,
default='U')
class Strategy(models.Model):
id = models.BigAutoField(primary_key=True)
title = models.CharField(max_length=15,
verbose_name=T("Strategy title"),
unique=True)
content = models.TextField(verbose_name=T("Strategy code"))
def __unicode__(self):
return '%s' % (self.title)
def __str__(self):
return '%s' % (self.title)
class Contacts(models.Model):
id = models.BigAutoField(primary_key=True)
name = models.CharField(max_length=120, verbose_name=T("Name"))
email = models.EmailField(max_length=100, verbose_name=T("Email"))
user = models.ForeignKey(QtraUser, verbose_name=T("User"))
subject = models.CharField(max_length=120, verbose_name=T("Subject"))
message = models.TextField(verbose_name=T("Message"))
def __unicode__(self):
return '(%s) %s %s' % (self.name, self.subject, self.message)
def __str__(self):
return '(%s) %s %s' % (self.name, self.subject, self.message)
class Deposit(models.Model):
month = models.ForeignKey(Month)
description = models.CharField(max_length=255)
amount = models.DecimalField(max_digits=6, decimal_places=2)
date = models.DateField(T('date deposited'))
deposit_type = models.ForeignKey(DepositType, null=True, blank=True, default=None)
account_number = models.CharField(T('opposite account number, if any'), max_length=34, blank=True, null=True)
def __unicode__(self):
return unicode('({}) {}'.format(self.date, self.description))
def __str__(self):
return self.__unicode__()
def cancel(_, up: tg.Update, __):
keyboard = tg.InlineKeyboardMarkup([[
tg.InlineKeyboardButton(T("Yes"),
callback_data=f"{cancel_confirm.__name__}1"),
tg.InlineKeyboardButton(T("No"),
callback_data=f"{cancel_confirm.__name__}0"),
]])
up.effective_message.reply_text(
text=T("Are you sure you want to cancel this appointment?"),
reply_markup=keyboard,
)
return ConversationHandler.END
def cancel_confirm(_, up: tg.Update, chat_data: dict):
query: tg.CallbackQuery = up.callback_query
confirmation = query.data[len(cancel_confirm.__name__):]
if bool(int(confirmation)):
appointment = chat_data["appointment"]
appointment.is_cancelled = True
appointment.save()
up.effective_message.edit_text(text=T("Okay, appointment cancelled."))
else:
up.effective_message.edit_text(
text=T("Appointment cancellation Aborted!"))
class BrokerForm(forms.Form):
broker = forms.ModelChoiceField(queryset=Brokers.objects.all(),
label=T('Broker:'),
required=True)
our_links = forms.BooleanField(
required=True,
widget=forms.CheckboxInput,
label=mark_safe(
T('I have opened live<br />account using <strong>your links</strong>:'
)))
account_id = forms.IntegerField(max_value=999999999,
required=True,
widget=forms.NumberInput,
label=T('My account number:'))
class Feedback(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=40, verbose_name=T("Your name"))
email = models.EmailField(max_length=60,
blank=False,
null=False,
verbose_name=T("Your email"))
message = models.TextField(verbose_name=T("Your message"))
def __unicode__(self):
return '(%s) %s' % (self.name, self.message)
def __str__(self):
return '(%s) %s' % (self.name, self.message)
class UserAuth(models.Model):
PROVIDERS = (
(1, "Facebook"),
(2, "Twitter"),
(3, "Google"),
(4, "LinkedIn"),
)
user = models.ForeignKey(CUser, on_delete=models.CASCADE, verbose_name=T("User"))
access_token = models.TextField()
provider = models.SmallIntegerField(choices=PROVIDERS)
avatar_url = models.URLField(verbose_name=T("Avatar URL"), null=True, blank=True)
user_pid = models.IntegerField(verbose_name=T("User ID at provider's"))
class Meta:
unique_together = ("user", "provider")
def start(_, up: tg.Update):
user = util.get_user(up)
if user.phone_number and user.email:
up.effective_message.reply_text(f"Welcome back {user.first_name}!")
show_help(_, up)
return ConversationHandler.END
up.effective_message.reply_text(
T(f"Welcome {user.first_name}!\nLet's get you started."))
util.request_phone_number(
up, T("First, could you please provide me your Phone Number?"))
return recv_phone_number.__name__
def book(_, up: tg.Update):
up.effective_message.reply_text(
T("Alright, let's book an Appointment.\n\n"
"First, enter the serial number of your Appliance:\n\n"
"(Case insensitive)"))
return recv_serial_number.__name__
class ScienceArticle(AutoSlugifyOnSaveModel):
if not settings.EXISTING_SITE:
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=250,
verbose_name=T("Article title"),
unique=True)
else:
title = models.CharField(max_length=250,
verbose_name=T("Article title"),
primary_key=True)
text = models.TextField(default='', verbose_name=T("Article text"))
summary = models.TextField(default='',
verbose_name=T("Article summary"))
sentiment = models.DecimalField(max_digits=3,
decimal_places=2,
blank=True,
null=True,
verbose_name=T("Sentiment"))
file = models.FileField(upload_to="uploads/research/",
blank=True,
null=True,
verbose_name=T("PDF"))
abs_url = models.URLField(verbose_name=T("URL to abstract"),
null=True,
blank=True)
pdf_url = models.URLField(verbose_name=T("URL to PDF"),
null=True,
blank=True)
date = models.DateTimeField(verbose_name=T("Date"),
null=True,
blank=True)
slug = models.CharField(max_length=140,
verbose_name=T("Article slug"),
blank=True,
null=True)
category = models.ForeignKey(ScienceCat, on_delete=models.CASCADE)
got_pdf = models.BooleanField(default=0)
class Meta:
ordering = ('date', )
def __unicode__(self):
return '%s' % (self.title)
def __str__(self):
return '%s' % (self.title)
class Category(AutoSlugifyOnSaveModel):
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=120,
verbose_name=T("Categoery"),
db_index=True,
unique=True)
slug = models.CharField(max_length=120, blank=True, null=True)
parsed = models.BooleanField(default=0, verbose_name=T("Parsed status"))
class Meta:
ordering = ('title', )
def __unicode__(self):
return '%s' % (self.title)
def __str__(self):
return '%s' % (self.title)
def request_phone_number(up: tg.Update, text: str) -> tg.Message:
keyboard_markup = [[
tg.KeyboardButton(text=T("Share Contact"), request_contact=True)
]]
reply_markup = tg.ReplyKeyboardMarkup(keyboard_markup)
return up.effective_message.reply_text(text=text,
reply_markup=reply_markup)
class Links(models.Model):
LINK_STATUSES = (
(0, 'Unknown'),
(1, 'Term link'),
(2, 'Article in db'),
)
url = models.URLField(verbose_name=T("URL to topic"), primary_key=True)
status_parsed = models.SmallIntegerField(verbose_name=T("Parse status"),
choices=LINK_STATUSES,
default=0)
def __unicode__(self):
return '%s' % (self.url)
def __str__(self):
return '%s' % (self.url)
def graph_creation(strategy, data, mae_, system_slug, symbol_slug, period,
direction, bh_title):
try:
if not (strategy is None):
strategy_ = strategy.loc[strategy != 0.0]
x = strategy.loc[strategy != 0].index
mae_ = mae_.loc[(mae_ != mae_.shift()) | (strategy != 0.0)]
#graphs
strategy_graph = go.Scatter(x=x, y=strategy_, mode="lines", \
name=T('Strategy'), line=dict(color=('rgb(205, 12, 24)'), width=6))
mae_graph = go.Scatter(x=x, y=mae_, mode="markers", \
name=T('Strategy MAE'), line=dict(color=('rgb(115,115,115,1)'), \
width=4, dash='dot'))
if not (data is None):
data_ = data.loc[strategy != 0.0]
data_graph = go.Scatter(x=x, y=data_, mode="lines", name=bh_title, \
line=dict(color=('rgb(22, 96, 167)'), width=4, dash='dot'))
title = "{0} on {1} {2} {3}".format(system_slug, symbol_slug, \
period, direction)
#else:
#title = "Portfolio {}".format(system_slug)
if not (data is None):
fig_data = go.Data([data_graph, strategy_graph, mae_graph], \
showgrid=True)
else:
fig_data = go.Data([strategy_graph, mae_graph], showgrid=True)
layout = go.Layout(title=title, xaxis={'title':T('Dates')}, \
yaxis={'title':T('$')}, font=dict(family='Courier New, \
monospace' , size=14, color='#7f7f7f') )
figure = go.Figure(data=fig_data, layout=layout)
graph = opy.plot(figure, auto_open=False, output_type='div')
else:
graph = None
return graph
except Exception as e:
#stck = inspect.stack()
#msg='{0} by {1}: {2}'.format(stck[0][3], stck[1][3], e)
#error_email(e=msg)
return None