class Chat_History(EmbeddedMongoModel):
datetimestamp = fields.DateTimeField()
c_id = fields.CharField()
chats = fields.EmbeddedDocumentListField(Chat)
class Renamed(User):
# Override existing field and change mongo_name
address = fields.CharField(mongo_name='mongo_address')
class CCAvenueConfig(BaseMongoModel):
id = fields.ObjectIdField(primary_key=True)
merchant_id = fields.CharField(required=True)
SECRET_working_key = fields.CharField(required=True)
access_code = fields.CharField(required=True)
class MultipleInheritanceModel(User, AnotherUser):
phone = fields.CharField() # Shadow phone field from ParentModel.
class Orders(MongoModel):
notification = fields.BooleanField(default = False)
invoiceURL = fields.CharField(default = "null")
userId = fields.CharField(default = "rootuser")
class Comment(MongoModel):
body = fields.CharField()
post = fields.ReferenceField(Post)
class Workflow(MongoModel):
name = fields.CharField(required=True)
display_name = fields.CharField(required=True)
steps = fields.ListField(fields.ReferenceField(Step))
valid_plate_types = fields.ListField(fields.CharField(choices=["96plate"]))
steps_denormalized = fields.ListField(fields.DictField())
def denormalize_steps(self):
steps_denormalized = []
for step in self.steps:
steps_denormalized.append({
"_id": step._id,
"name": step.name,
"category": step.category
})
self.steps_denormalized = steps_denormalized
class Meta:
indexes = [IndexModel([("name", 1)], unique=True)]
@classmethod
def get_workflows(cls):
"""
Returns list of available workflows
"""
workflows = cls.objects.raw({}).project({
"name": 1,
"display_name": 1,
"valid_plate_types": 1,
"_id": 0
})
return [x.to_son().to_dict() for x in workflows]
@staticmethod
def find_steps(step_names):
"""
Provided a list of step names, it will search and
add them to self.steps as references.
Steps must exist already.
"""
step_o_list = []
for step in step_names:
step_o_list.append(Step.objects.get({"name": step}))
return step_o_list
def valid_next_step(self, last_step, next_step):
i = None
if last_step == "root":
i = -1
else:
for i in range(len(self.steps_denormalized)):
if self.steps_denormalized[i]["category"] == last_step:
break
if i is None or i == len(
self.steps_denormalized) - 1: # none or last step
return False
next_s = self.steps_denormalized[i + 1]
if next_step == next_s["category"]:
return True
else:
return False
def get_prev_step(self, step_name):
"""
Returns previous step to the one provided.
"""
index = None
for i in range(len(self.steps_denormalized)):
step = self.steps_denormalized[i]
if step["name"] == step_name:
index = i
if index is None:
raise ValueError("Step not in workflow")
if index == 0:
return "root"
else:
return self.steps_denormalized[index - 1]["name"]
def next_step(self, step_name):
"""
Returns next step to the one provided. None if last step
"""
index = None
for i in range(len(self.steps_denormalized)):
step = self.steps_denormalized[i]
if step["name"] == step_name:
index = i
if index is None:
raise ValueError("Step not in workflow")
if index == len(self.steps_denormalized) - 1:
return "_workflow_finished"
else:
return self.steps_denormalized[index + 1]["name"]
class WebPage(MongoModel):
id = fields.CharField(primary_key=True)
url = fields.CharField()
title = fields.CharField()
web_link = fields.ListField(fields.CharField())
class Step_instance(MongoModel):
step = fields.ReferenceField(Step, required=True)
start_date = fields.DateTimeField(required=True,
default=datetime.datetime.now())
finish_date = fields.DateTimeField()
instrument = fields.CharField(required=True)
status = fields.CharField(required=True,
default="started",
choices=("started", "finished", "cancelled"))
user_started = fields.ReferenceField(User, required=True)
user_ended = fields.ReferenceField(User)
comment = fields.CharField()
# result_input_ = fields.DictField()
# outputFiles = fields.DictField()
samples = fields.ListField(fields.ReferenceField(Sample), required=True)
result_samples = fields.DictField(required=True)
result_all = fields.DictField(blank=True)
qc_actions = fields.DictField(blank=True)
batch = fields.CharField()
workflow = fields.ReferenceField(Workflow, required=True)
@staticmethod
def _clean_param(p):
return p.replace(".", "_").replace("-", "_")
@staticmethod
def invalid_comb(t, s):
raise ValueError(
"Invalid param combination: type {}. scope: {}".format(t, s))
@staticmethod
def invalid_param(s):
raise ValueError("Invalid param: {}".format(s))
def _get_result(self, fieldname, barcode=None):
try:
if barcode is None:
return self.result_all[fieldname]
else:
return self.result_samples[barcode][fieldname]
except KeyError:
return None
# raise minilims.errors.MissingValueError(
# "Value {} for barcode {} not found in results.".format(fieldname, barcode))
def set_batch(self, batch_list):
self.batch = batch_list
self.save()
def _get_param(self, param_name: str, scope: str):
"""Parses the param name and gets the value back
Args:
param_name (str): Right now the format is step.field, but can be expanded to workflow.step.field
scope (str): "all" or "sample"
Raises:
ValueError: [description]
Returns:
[type]: [description]
"""
fields = param_name.split(".")
sample_dict = {}
if len(fields) == 1:
# Same step
workflow_name = None
step_name = None
field_name = param_name
if scope == "all":
for sample in self.samples:
sample_dict[sample.barcode] = self._get_result(param_name)
else: # "sample"
for sample in self.samples:
sample_dict[sample.barcode] = self._get_result(
field_name, sample.barcode)
elif len(fields) == 2:
# other step, any workflow
workflow_name = None
step_name = fields[0]
field_name = fields[1]
for sample in self.samples:
potential_workflows = sample.find_workflow_for_step(step_name)
if len(potential_workflows) > 1:
current_app.logging.warning(
("Sample {} requests data for step {} but more than "
"one workflow is available ({}), using the first one"
).format(sample.barcode, param_name,
potential_workflows))
workflow_name = potential_workflows[0]
sample_dict[sample.barcode] = sample.find_result(
workflow_name, step_name, scope, field_name, self)
elif len(fields) == 3:
# other step, other workflow
workflow_name = fields[0]
step_name = fields[1]
field_name = fields[2]
for sample in self.samples:
sample_dict[sample.barcode] = sample.find_result(
workflow_name, step_name, scope, field_name, self)
else:
raise ValueError(
"Invalid param name. Max 2 '.' allowed. Used to separate workflow.step_name.fieldname"
)
return sample_dict
def _get_params(self, script):
"""
Get parameters according to the script instructions
"""
params = {}
ivs = script.input_values
for iv in ivs:
if iv.type_ == "sample_properties":
if iv.scope == "sample":
if iv.name == "batch":
params[self._clean_param(
iv.name)] = self._get_sample_batch_info()
else:
self.invalid_comb(iv.type_, iv.scope)
else:
if iv.name == "samples":
params[self._clean_param(iv.name)] = self.samples
else:
self.invalid_comb(iv.type_, iv.scope)
elif iv.type_ == "user_started":
if iv.scope == "all":
params[self._clean_param(iv.name)] = self.user_started
else:
self.invalid_comb(iv.type_, iv.scope)
elif iv.type_ == "user_ended":
if iv.scope == "all":
params[self._clean_param(iv.name)] = self.user_ended
else:
self.invalid_comb(iv.type_, iv.scope)
elif iv.type_ == "file":
if iv.scope == "all":
if iv.name.count(".") != 0:
self.invalid_param(
"Invalid file field name '{}'. Character '.' is only allowed to specify 'step.field', but 'file' values with 'all' scope can only be from the same step."
.format(iv.name))
else:
fileid = self._get_result(iv.name)
# params[iv.name] = fileutils.get_file(fileid)
params[self._clean_param(iv.name)] = fileid
else:
self.invalid_comb(iv.type_, iv.scope)
else:
params[self._clean_param(iv.name)] = self._get_param(
iv.name, iv.scope)
# else:
# self.invalid_comb(iv.type_, iv.scope)
# Much more work to do here.
return params
def save_files(self, files):
for fieldname, fileobject in files.items():
_id = fileutils.save_file(fieldname, fileobject)
fieldname = fieldname.replace(".", "_")
self.result_all[fieldname] = _id
def delete_files(self, files):
"""
Reverse save_files
"""
for fieldname, fileobject in files.items():
fieldname = fieldname.replace(".", "_")
_id = self.result_all[fieldname]
fileutils.delete_file(_id)
self.result_all.pop(fieldname)
def save_params(self, params):
"""Saves params in step_results.
params format::
{
"files": {
"fieldname": fileobject,
"fieldname2": fileobject2,
},
"params": {
"all": {
"fieldname": value1,
"fieldname2": value2,
},
"samples" : {
"barcode1" : {
"fieldname1": value1,
...
},
...
}
}
}
Args:
params (Dict): See format in description
"""
if "files" in params:
self.save_files(params["files"])
if "params" in params:
if "all" in params["params"]:
for fieldname, fieldvalue in params["params"]["all"].items():
self.result_all[fieldname] = fieldvalue
if "samples" in params["params"]:
for barcode, sampleparams in params["params"]["samples"].items(
):
for fieldname, fieldvalue in params["params"]["samples"][
barcode]:
self.result_samples[barcode][fieldname] = fieldvalue
self.save()
def remove_params(self, params):
"""Reverse save_params
Args:
params (Dict): Same as params from save_params.
"""
if "files" in params:
self.save_files(params["files"])
if "params" in params:
if "all" in params["params"]:
for fieldname in params["params"]["all"].keys():
self.result_all.pop(fieldname, None)
if "samples" in params["params"]:
for barcode in params["params"]["samples"].keys():
for fieldname, fieldvalue in params["params"]["samples"][
barcode]:
self.result_samples[barcode].pop(fieldname, None)
self.save()
def run_scripts(self, stage: str) -> None:
"""Run all scripts for this step in specified stage.
Args:
stage (str): Which step stage to run scripts for. "stepstart" or "stepend"
"""
for script in self.step.input_output:
if stage in ("stepstart", "stepend"):
if script.stage == stage and script.script:
params = self._get_params(script)
results = self.step.run_script(script, params)
print(results)
# Right now the "output_values" property from
# input_output object is not used
# Save "all" results
for key, value in results.get("all", {}).items():
self.result_all[key] = value
# Save "samples" results
if "samples" in results:
for barcode, sample_result in results["samples"].items(
):
for key, value in sample_result.items():
self.result_samples[barcode][key] = value
if "qc_actions" in results:
self.qc_actions = results["qc_actions"]
elif stage == "qc" and script.stage == stage:
self.step.run_qc_script(script, self)
self.save()
def qc_actions_msg(self):
if len(self.qc_actions) == 0:
return []
to_steps = {}
for bc, step in self.qc_actions.items():
if step in to_steps:
to_steps[step].append(bc)
else:
to_steps[step] = [bc]
messages = []
for step, samples in to_steps.items():
step_o = Step.objects.get({"name": step})
messages.append("Samples {}: {}".format(
", ".join(samples),
"Unassigned from workflow. Recommended to send to: {}.".format(
step_o.display_name)))
return "QC issues: " + ".".join(messages)
def _get_sample_batch_info(self):
batch_info = {}
for sample in self.samples:
for batch in sample.batches:
if batch.batch_name == self.batch:
batch_info[sample.barcode] = batch
return batch_info
def qc_reassign_data(self):
data = {}
#Only takes one suggested step per step instance
reassign = list(set(self.qc_actions.values()))
if len(reassign):
data["suggested_step"] = reassign[0]
data["samples"] = list(self.qc_actions.keys())
data["workflow"] = {
"name": self.workflow.name,
"display_name": self.workflow.display_name,
"plate_types": self.workflow.valid_plate_types
}
return data
else:
return {}
def summary_values(self):
summary = {}
summary["values_samples"] = {}
summary["fields_samples"] = []
summary["values_all"] = []
for s, v_dict in self.result_samples.items():
s_dict = {}
for k, v in v_dict.items():
if isinstance(v, ObjectId):
v_type = "file"
v = url_for('lims.getfile', fileid=v)
else:
v_type = "value"
s_dict[k] = v
if (k, v_type) not in summary["fields_samples"]:
summary["fields_samples"].append((k, v_type))
summary["values_samples"][s] = s_dict
for k, v in self.result_all.items():
if isinstance(v, ObjectId):
v_type = "file"
v = url_for('lims.getfile', fileid=v)
else:
v_type = "value"
summary["values_all"].append({
"name": k,
"value": v,
"type": v_type
})
return summary
def summary(self, values=False):
"""
Summary generated for finished_step view and step summary view (not done yet)
"""
summary = {
"display_name": self.step.display_name,
"start_date": self.start_date,
"finish_date": self.finish_date,
"num_samples": len(self.samples),
"id": self._id,
"batch": self.batch,
"samples": [s.barcode for s in self.samples]
}
if values:
val = self.summary_values()
summary["values_samples"] = val["values_samples"]
summary["values_all"] = val["values_all"]
summary["fields_samples"] = val["fields_samples"]
return summary
class User(MongoModel):
username = fields.CharField()
def get_posts(self):
return list(Post.manager.posts_by_user(self._id))
class BookCredit(MongoModel):
first_name = fields.CharField()
last_name = fields.CharField()
role = fields.CharField(choices=[('A', 'author'), ('E', 'editor')])
contributors = CustomManager()
more_contributors = CustomManager()
class IterAssitant(MongoModel):
index_key = fields.CharField(default=None, required=True, blank=False)
file_name = fields.CharField(default=None, blank=True)
summary = fields.DictField(default=None, blank=True)
boundary_lower = fields.IntegerField(default=None, blank=True)
boundary_upper = fields.IntegerField(default=None, blank=True)
max_num = fields.IntegerField(default=None, blank=True)
# iter_index should fall in [boundary_lower, boundary_upper)
start_index = fields.IntegerField(default=None, blank=True)
error_indices = fields.ListField(default=[], blank=True)
# cursor is next cursor because cursor is both input and output
cursor = fields.CharField(default=None, blank=True)
error_cursors = fields.ListField(default=[], blank=True)
# query is last query because query is input
query = fields.DictField(default=None, blank=True)
error_queries = fields.ListField(default=[], blank=True)
class Meta:
# https://pymodm.readthedocs.io/en/stable/api/index.html#metadata-attributes
collection_name = ''
indexes = [
IndexModel(keys=[('index_key', HASHED)]),
]
ignore_unknown_fields = True
final=False
def save_entry(self, save_to='mongo_db'):
if save_to == 'mongo_db':
self.save()
else:
if not getattr(self, '_id'):
setattr(
self,
'_id',
ObjectId(),
)
if os.path.exists(save_to):
with open(save_to, 'r') as fr:
all_entries = json.load(fr)
else:
all_entries = {}
all_entries[str(self._id)] = self.to_son()
with open(save_to, 'w') as fw:
json.dump(all_entries, fw, indent=2, default=json_util.default)
def refresh_entry(self, save_to='mongo_db'):
if save_to == 'mongo_db':
self.refresh_from_db()
else:
if not getattr(self, '_id'):
return
if not os.path.exists(save_to):
return
with open(save_to, 'r') as fr:
all_entries = json.load(fr)
if str(self._id) not in all_entries:
return
for k, v in all_entries[str(self._id)].items():
if k == '_id':
continue
setattr(self, k, v)
@classmethod
def find_all(cls, source=None, save_to='mongo_db'):
if save_to == 'mongo_db':
return cls.objects.raw(source)
else:
if os.path.exists(save_to):
with open(save_to, 'r') as fr:
all_entries = json.load(fr)
entries_recoveried = []
for k, v in all_entries.items():
del v['_id']
entries_recoveried.append(cls(**v, _id=ObjectId(k)))
return entries_recoveried
else:
return []
@classmethod
def get_iter_index(
cls,
source: dict,
data_len: int=None,
data: Any=None,
segment_len: int=None,
additional_filter: dict=None,
**kwargs
):
# TODO: separate this function into two: create and query
# get data_len
if (data_len is None) and (data is not None):
data_len = len(data)
# get iter_index of the task
iter_index = list(cls.find_all(source=source, save_to=SAVE_TO))
if len(iter_index) == 0 and (data_len is not None):
assert (data_len is not None)
# get segment_len
if segment_len is None:
segment_len = data_len
# get num_segs
num_segs = math.ceil(data_len/float(segment_len))
for i in range(num_segs):
# create one if no iter_index found
new_index = cls(
index_key=source['index_key'],
file_name=source.get('file_name'),
summary=source.get('summary'),
cursor=kwargs.get('start_cursor'),
query=kwargs.get('start_query'),
start_index=i*segment_len+kwargs.get('start_index', 0),
boundary_lower=i*segment_len+kwargs.get('start_index', 0),
boundary_upper=min(
(i+1)*segment_len, data_len
) + kwargs.get('start_index', 0),
max_num=data_len+kwargs.get('start_index', 0),
)
# set extra parameters in sub classes
self_fields = cls.get_db_fields()
base_fields = IterAssitant.get_db_fields()
for f in (set(self_fields) - set(base_fields)):
if f not in kwargs:
continue
setattr(new_index, f, kwargs[f])
new_index.save_entry(save_to=SAVE_TO)
iter_index.append(new_index)
if additional_filter is not None:
iter_index = list(cls.find_all(
source={**source, **additional_filter},
save_to=SAVE_TO
))
if len(iter_index) == 0:
return None
# random select one if multiple records found
iter_index = random.choice(iter_index)
if (data_len is not None) and (iter_index.max_num < data_len):
iter_index.max_num = data_len
iter_index.save_entry(save_to=SAVE_TO)
return iter_index
@staticmethod
def generate_download_url(
base_url: str,
basename: Union[int, str],
):
# return example: https://bulkdata.uspto.gov/data/patent/grant/redbook/fulltext/1971
if not base_url.endswith('/'):
base_url += '/'
url = urllib.parse.urljoin(base_url, str(basename))
return url
@staticmethod
def get_url_basename(url):
if url.endswith('/'):
url = url.rstrip('/')
return os.path.basename(url)
@classmethod
def get_db_fields(cls):
db_fields = []
for f in dir(cls):
if isinstance(getattr(cls, f), fields.MongoBaseField):
db_fields.append(f)
return db_fields
@classmethod
def is_db_connected(cls):
is_connected = False
connected_db_names = set([
x.parsed_uri['database'] for x in pymodm.connection._CONNECTIONS.values()
])
db_name = None
if 's_db_name' in dir(cls.Meta):
db_name = cls.Meta.s_db_name
if db_name is not None:
if db_name in connected_db_names:
is_connected = True
else:
if len(connected_db_names) > 0:
is_connected = True
return is_connected
class CTFModel(MongoModel):
name = fields.CharField(required=True)
guild_id = fields.IntegerField()
category_id = fields.IntegerField()
role_id = fields.IntegerField()
description = fields.CharField()
created_at = fields.DateTimeField(required=True)
finished_at = fields.DateTimeField()
start_date = fields.DateTimeField()
end_date = fields.DateTimeField()
url = fields.URLField()
username = fields.CharField()
password = fields.CharField()
challenges = fields.EmbeddedDocumentListField(Challenge,
default=[],
blank=True)
pending_reminders = fields.ListField(blank=True, default=[])
tags = fields.ListField(fields.CharField(), default=[], blank=True)
def status(self, members_joined_count):
description_str = self.description + "\n" if self.description else ""
solved_count = len(
list(filter(lambda x: x.solved_at is not None, self.challenges)))
total_count = len(self.challenges)
status = (
f":triangular_flag_on_post: **{self.name}** ({members_joined_count} Members joined)\n{description_str}"
# + f"```CSS\n{draw_bar(solved_count, total_count, style=5)}\n"
+ f" {solved_count} Solved / {total_count} Total")
if self.start_date:
fmt_str = "%d/%m %H:\u200b%M"
start_date_str = self.start_date.strftime(fmt_str)
end_date_str = self.end_date.strftime(
fmt_str) if self.end_date else "?"
status += f"\n {start_date_str} - {end_date_str}\n"
status += "```"
return status
def credentials(self):
response = f":busts_in_silhouette: **Username**: {self.username}\n:key: **Password**: {self.password}"
if self.url is not None:
response += f"\n\nLogin Here: {self.url}"
return response
def get_chal_hash(self, name):
return hashlib.sha1(
f'{self.category_id}{name}'.encode()).hexdigest()[:7]
def get_challenge(self, name):
challenge = next(
(c for c in self.challenges
if c.name == name or self.get_chal_hash(c.name) == name), None)
if not challenge:
raise NotFound("Challenge not found.")
return challenge
# return next((c for c in self.challenges if c.name == name or self.get_chal_hash(c.name) == name), None)
def challenge_summary(self, category):
if len(self.challenges) == 0:
raise NotFound(
"No challenges found. Add one with `>challenge add <name> <category>`"
)
solved_response, unsolved_response = "", ""
challenges = self.challenges
if category and category != 'all':
challenges = filter(lambda c: category in c.tags, challenges)
challenges = sorted(challenges,
key=lambda c:
(c.tags, c.name, c.solved_at or c.created_at))
for challenge in challenges:
chal_hash = self.get_chal_hash(challenge.name)
challenge_details = f'[{chal_hash} :: {challenge.name}]'
notes_url = f'[notes]({challenge.notebook_url})'
flag = f'{{{challenge.flag or ""}}}'
tags = ",".join(challenge.tags)
if challenge.solved_at:
solved_response += f'> {challenge_details}({tags}) <{",".join(challenge.solved_by)}> {flag}\n'
else:
if len(challenge.working_on) > 0:
unsolved_response += f'* {challenge_details}({tags}) <{",".join(challenge.working_on)}> {flag}\n'
else:
unsolved_response += f'< {challenge_details}({tags}) < -- > {flag}\n'
return solved_response, unsolved_response
class Meta:
collection_name = "ctf"
ignore_unknown_fields = True
indexes = [
IndexModel([('guild_id', 1), ('name', 1)], unique=True),
IndexModel([('guild_id', 1), ('category_id', 1)], unique=True)
]
class InventoryItem(EmbeddedMongoModel):
name = fields.CharField(required=True)
amount = fields.IntegerField(default=0)
class Image(EmbeddedMongoModel):
image_url = fields.CharField(required=True)
alt_text = fields.CharField()
photographer = fields.ReferenceField(Contributor)
class OriginalImages(MongoModel):
name = fields.CharField()
b64_string = fields.CharField()
upload_timestamp = fields.CharField()
upload_size = fields.ListField()
class Post(MongoModel):
body = fields.CharField()
images = fields.EmbeddedDocumentListField(Image)
class InvertedImages(MongoModel):
name_inv = fields.CharField()
b64_string_inv = fields.CharField()
processed_timestamp = fields.CharField()
processed_size = fields.ListField()
class ShortLink(MongoModel):
shortLink = fields.CharField(primary_key=True)
longLink = fields.CharField()
class AtributoDict(EmbeddedMongoModel):
nombre = fields.CharField()
descripcion = fields.CharField()
class Karma(MongoModel):
@staticmethod
def _get_current_net_karma(**kwargs) -> list:
# aggregate defaults
projection = {"$project": {"_id": "$_id", "recipient": {"$toLower": "$awarded_to_username"},
"net_karma": {"$cond": [{"$eq": ["$karma_type", str(KarmaType.POZZYPOZ)]}, 1, -1]},
"awarded": "$awarded"}}
match = {"$match": {'awarded': {'$gt': _get_cut_off_date()}}}
grouping = {"$group": {"_id": "$recipient", "net_karma": {"$sum": "$net_karma"}}}
sort = {"$sort": {"net_karma": -1}}
limit = 3
# kwarg aggregate overrides
if "recipient" in kwargs:
match["$match"]["recipient"] = str(kwargs["recipient"]).lower()
if "sort" in kwargs and kwargs["sort"] == "asc":
sort["$sort"]["net_karma"] = 1
if "limit" in kwargs:
limit = int(kwargs["limit"])
# execution
query_set = Karma.objects.aggregate(projection,
match,
grouping,
sort)
result_set = list(query_set)[:limit]
return [{"username": r["_id"], "net_karma": r["net_karma"]} for r in result_set]
@staticmethod
def get_leader_board(size: int=3) -> list:
return Karma._get_current_net_karma(limit=size)
@staticmethod
def get_loser_board(size: int=3) -> list:
return Karma._get_current_net_karma(limit=size, sort="asc")
@staticmethod
def get_current_net_karma_for_recipient(recipient: str) -> int:
net_karma_results = Karma._get_current_net_karma(recipient=recipient)
if len(net_karma_results) == 0:
return 0
recipient_net_karma = net_karma_results[0]
return recipient_net_karma["net_karma"]
@staticmethod
def get_current_karma_reasons_for_recipient(recipient: str) -> dict:
projection = {"$project": {"_id": "$_id",
"awarded_to_username": {"$toLower": "$awarded_to_username"},
"awarded_by_username": {"$toLower": "$awarded_by_username"},
"karma_type": "$karma_type",
"awarded": "$awarded",
"reason": "$reason"
}}
match = {'$match': {'awarded_to_username': recipient.lower(),
'awarded': {'$gt': _get_cut_off_date()}}}
query_set = Karma.objects.aggregate(projection, match)
recent_karma = [Karma(awarded_to_username=k["awarded_to_username"],
awarded_by_username=k["awarded_by_username"],
karma_type=k["karma_type"],
awarded=k["awarded"],
reason=k["reason"],
_id=k["_id"]) for k in list(query_set)]
karma_with_reasons = [k for k in recent_karma if k.reason != Karma.default_reason]
karma_without_reasons = [k for k in recent_karma if k.reason == Karma.default_reason]
return {'reasonless': len(karma_without_reasons), 'reasoned': karma_with_reasons}
awarded_to_username = fields.CharField()
default_reason = ""
awarded_by_username = fields.CharField()
reason = fields.CharField(blank=True)
awarded = fields.DateTimeField()
karma_type = fields.CharField()
def validate_auto_pozzypoz(self):
valid = True
if self.karma_type == str(KarmaType.POZZYPOZ):
valid = self.awarded_by_username != self.awarded_to_username # can't give yourself positive karma
if not valid:
raise ValidationError("Can't give yourself positive karma")
def clean(self):
self.validate_auto_pozzypoz()
class Meta:
write_concern = WriteConcern(j=True)
connection_alias = Config.Connection
class AtributoDictList(EmbeddedMongoModel):
nombre = fields.CharField()
list_atributos_dict = fields.EmbeddedDocumentListField(AtributoDict,
default=[])
class DerivedClass(BaseClass):
dspecific = fields.CharField()
class AtributoMagnitudDict(EmbeddedMongoModel):
nombre = fields.CharField()
valor = fields.FloatField()
unidades = fields.FloatField()
descripcion = fields.CharField()
class BookmarksVersion(MongoModel):
page = fields.ReferenceField(BookmarksPage)
timestamp = fields.DateTimeField()
sections = fields.EmbeddedDocumentListField(Section, blank=True)
summary = fields.CharField(blank=True)
links = fields.ListField(fields.CharField(), default=[], blank=True)
class SubCategoriaModel(EmbeddedMongoModel):
codigo = fields.CharField()
nombre = fields.CharField()
descripcion = fields.CharField()
imagen = fields.CharField()
from pymongo import TEXT
from pymodm import connect, fields, MongoModel, EmbeddedMongoModel
from bson.objectid import ObjectId
import datetime
import os
import pymodm
from bson.json_util import dumps, RELAXED_JSON_OPTIONS, DatetimeRepresentation
import json
currency_field = fields.CharField(required=True, choices=("USD", "INR"))
money_field = fields.CharField(required=True)
class BaseMongoModel(MongoModel):
def save(self, *args, **kwargs):
if not self.id:
self.id = ObjectId()
self.date_created = datetime.datetime.now()
self.date_modified = datetime.datetime.now()
super(BaseMongoModel, self).save(*args, **kwargs)
class Meta:
collection_name = os.getenv("DB_NAME", "cff_dev")
class Center(EmbeddedMongoModel):
name = fields.CharField()
class User(BaseMongoModel):
name = fields.CharField(blank=True)
class Contributor(MongoModel):
name = fields.CharField()
thumbnail = fields.EmbeddedDocumentField('Image')
class Center(EmbeddedMongoModel):
name = fields.CharField()
class Agent(MongoModel):
course_id = fields.CharField()
file_name = fields.CharField()
project_id = fields.CharField()
