class Deployment(DocumentSchema, UpdatableSchema): date = DateTimeProperty() city = StringProperty() country = StringProperty() region = StringProperty() # e.g. US, LAC, SA, Sub-saharn Africa, East Africa, West Africa, Southeast Asia) description = StringProperty() public = BooleanProperty(default=False)
class SavedBasicExport(Document): """ A cache of an export that lives in couch. Doesn't do anything smart, just works off an index """ configuration = SchemaProperty(ExportConfiguration) last_updated = DateTimeProperty() @property def size(self): try: return self._attachments[self.get_attachment_name()]["length"] except KeyError: return 0 def has_file(self): return self.get_attachment_name() in self._attachments def get_attachment_name(self): # obfuscate this because couch doesn't like attachments that start with underscores return hashlib.md5( unicode(self.configuration.filename).encode('utf-8')).hexdigest() def set_payload(self, payload): self.put_attachment(payload, self.get_attachment_name()) def get_payload(self): return self.fetch_attachment(self.get_attachment_name())
class LicenseAgreement(DocumentSchema): signed = BooleanProperty(default=False) type = StringProperty() date = DateTimeProperty() user_id = StringProperty() user_ip = StringProperty() version = StringProperty()
class ComputedDocumentMixin(DocumentSchema): """ Use this mixin for things like CommCareCase or XFormInstance documents that take advantage of indicator definitions. computed_ is namespaced and may look like the following for indicators: computed_: { mvp_indicators: { indicator_slug: { version: 1, value: "foo" } } } """ computed_ = DictProperty() computed_modified_on_ = DateTimeProperty() # a flag for the indicator pillows so that there aren't any Document Update Conflicts initial_processing_complete = BooleanProperty(default=False) def update_indicator(self, indicator_def, save_on_update=True): existing_indicators = self.computed_.get(indicator_def.namespace, {}) updated_indicators, is_update = indicator_def.update_computed_namespace( existing_indicators, self) if is_update: self.computed_[indicator_def.namespace] = updated_indicators self.computed_modified_on_ = datetime.datetime.utcnow() if save_on_update: self.save() return is_update
class XFormsSession(Document): """ Keeps information about an SMS XForm session. """ # generic properties connection_id = StringProperty() session_id = StringProperty() form_xmlns = StringProperty() start_time = DateTimeProperty() modified_time = DateTimeProperty() end_time = DateTimeProperty() completed = BooleanProperty() # HQ specific properties domain = StringProperty() user_id = StringProperty() app_id = StringProperty() submission_id = StringProperty() survey_incentive = StringProperty() session_type = StringProperty(choices=XFORMS_SESSION_TYPES, default=XFORMS_SESSION_SMS) def save(self, *args, **kwargs): if is_bigcouch() and "w" not in kwargs: # Force a write to all nodes before returning kwargs["w"] = bigcouch_quorum_count() return super(XFormsSession, self).save(*args, **kwargs) def __unicode__(self): return 'Form %(form)s in domain %(domain)s. Last modified: %(mod)s' % \ {"form": self.form_xmlns, "domain": self.domain, "mod": self.modified_time} def end(self, completed): """ Marks this as ended (by setting end time). """ self.completed = completed self.modified_time = self.end_time = datetime.utcnow() @classmethod def latest_by_session_id(cls, id): return XFormsSession.view("smsforms/sessions_by_touchforms_id", startkey=[id], endkey=[id, {}], include_docs=True).one()
class CObservationAddendum(Document): observed_date = DateProperty() art_observations = SchemaListProperty(CObservation) nonart_observations = SchemaListProperty(CObservation) created_by = StringProperty() created_date = DateTimeProperty() notes = StringProperty() # placeholder if need be class Meta: app_label = 'pact'
class MobileAuthKeyRecord(Document): """ Data model for generating the XML for mobile auth (from https://bitbucket.org/commcare/commcare/wiki/CentralAuthAPI) """ domain = StringProperty() user_id = StringProperty() valid = DateTimeProperty() expires = DateTimeProperty() type = StringProperty(choices=['AES256'], default='AES256') key = StringProperty() def __init__(self, *args, **kwargs): super(MobileAuthKeyRecord, self).__init__(*args, **kwargs) if not self.key: self.key = generate_aes_key() if not self._id: self._id = self.get_db().server.next_uuid() @property def uuid(self): return self.get_id @classmethod def current_for_user(cls, domain, user_id, now=None): now = now or datetime.utcnow() now_json = json_format_datetime(now) key_record = cls.view( 'mobile_auth/key_records', startkey=[domain, user_id, now_json], endkey=[domain, user_id, ""], descending=True, limit=1, include_docs=True, ).first() if key_record and now < key_record.expires: return key_record else: return None
class RegistrationRequest(Document): tos_confirmed = BooleanProperty(default=False) request_time = DateTimeProperty() request_ip = StringProperty() activation_guid = StringProperty() confirm_time = DateTimeProperty() confirm_ip = StringProperty() domain = StringProperty() new_user_username = StringProperty() requesting_user_username = StringProperty() @property @memoized def project(self): return Domain.get_by_name(self.domain) @classmethod def get_by_guid(cls, guid): result = cls.view("registration/requests_by_guid", key=guid, reduce=False, include_docs=True).first() return result @classmethod def get_requests_today(cls): today = datetime.datetime.utcnow() yesterday = today - datetime.timedelta(1) result = cls.view("registration/requests_by_time", startkey=yesterday.isoformat(), endkey=today.isoformat(), reduce=True).all() if not result: return 0 return result[0]['value'] @classmethod def get_request_for_username(cls, username): result = cls.view("registration/requests_by_username", key=username, reduce=False, include_docs=True).first() return result
class HQAnnouncement(Document, AdminCRUDDocumentMixin): """ For global, site-wide HQ Announcements. """ title = StringProperty() summary = StringProperty() highlighted_selectors = StringListProperty() date_created = DateTimeProperty() valid_until = DateTimeProperty() show_to_new_users = BooleanProperty(default=False) base_doc = "HQAnnouncement" _admin_crud_class = HQAnnouncementCRUDManager @property def as_html(self): return render_to_string("announcements/partials/base_announcement.html", { 'title': self.title, 'content': self.summary, 'announcement_id': self._id, })
class CDotWeeklySchedule(Document): """Weekly schedule where each day has a username""" schedule_id = StringProperty(default=make_uuid) sunday = StringProperty() monday = StringProperty() tuesday = StringProperty() wednesday = StringProperty() thursday = StringProperty() friday = StringProperty() saturday = StringProperty() comment = StringProperty() deprecated = BooleanProperty(default=False) started = DateTimeProperty(default=datetime.utcnow, required=True) ended = DateTimeProperty() created_by = StringProperty() #userid edited_by = StringProperty() #userid def weekly_arr(self): return [ "Sun: %s" % self.sunday, "Mon: %s" % self.monday, "Tue: %s" % self.tuesday, "Wed: %s" % self.wednesday, "Thu: %s" % self.thursday, "Fri: %s" % self.friday, "Sat: %s" % self.saturday, "Deprecated: %s" % self.deprecated, "Started: %s" % self.started, "Ended: %s" % self.ended, ] class Meta: app_label='pact'
class LockableMixIn(DocumentSchema): lock_date = DateTimeProperty() def acquire_lock(self, now): """ Returns True if the lock was acquired by the calling thread, False if another thread acquired it first """ if (self.lock_date is None) or (now > (self.lock_date + LOCK_EXPIRATION)): try: self.lock_date = now self.save() return True except ResourceConflict: return False else: return False def release_lock(self): assert self.lock_date is not None self.lock_date = None self.save()
class XFormsSession(Document): """ Keeps information about an SMS XForm session. """ # generic properties connection_id = StringProperty() session_id = StringProperty() form_xmlns = StringProperty() start_time = DateTimeProperty() modified_time = DateTimeProperty() end_time = DateTimeProperty() completed = BooleanProperty() # HQ specific properties domain = StringProperty() user_id = StringProperty() app_id = StringProperty() submission_id = StringProperty() survey_incentive = StringProperty() session_type = StringProperty(choices=XFORMS_SESSION_TYPES, default=XFORMS_SESSION_SMS) workflow = StringProperty( ) # One of the corehq.apps.sms.models.WORKFLOW_* constants describing what kind of workflow this session was a part of reminder_id = StringProperty( ) # Points to the _id of an instance of corehq.apps.reminders.models.CaseReminder that this session is tied to def save(self, *args, **kwargs): if is_bigcouch() and "w" not in kwargs: # Force a write to all nodes before returning kwargs["w"] = bigcouch_quorum_count() return super(XFormsSession, self).save(*args, **kwargs) def __unicode__(self): return 'Form %(form)s in domain %(domain)s. Last modified: %(mod)s' % \ {"form": self.form_xmlns, "domain": self.domain, "mod": self.modified_time} def end(self, completed): """ Marks this as ended (by setting end time). """ self.completed = completed self.modified_time = self.end_time = datetime.utcnow() @property def is_open(self): """ True if this session is still open, False otherwise. """ return self.end_time is None @classmethod def get_all_open_sms_sessions(cls, domain, contact_id): sessions = cls.view("smsforms/open_sms_sessions_by_connection", key=[domain, contact_id], include_docs=True).all() return sessions @classmethod def close_all_open_sms_sessions(cls, domain, contact_id): sessions = cls.get_all_open_sms_sessions(domain, contact_id) for session in sessions: session.end(False) session.save() @classmethod def latest_by_session_id(cls, id): return XFormsSession.view("smsforms/sessions_by_touchforms_id", startkey=[id], endkey=[id, {}], include_docs=True).one() @classmethod def get_open_sms_session(cls, domain, contact_id): """ Looks up the open sms survey session for the given domain and contact_id. Only one session is expected to be open at a time. Raises MultipleResultsFound if more than one session is open. """ session = cls.view("smsforms/open_sms_sessions_by_connection", key=[domain, contact_id], include_docs=True).one() return session
class CObservation(Document): doc_id = StringProperty() patient = StringProperty() #case id pact_id = StringProperty() #patient pact id provider = StringProperty() encounter_date = DateTimeProperty() anchor_date = DateTimeProperty() observed_date = DateTimeProperty() submitted_date = DateTimeProperty() created_date = DateTimeProperty() is_art = BooleanProperty() dose_number = IntegerProperty() total_doses = IntegerProperty() adherence = StringProperty() # DOT_OBSERVATION_ types method = StringProperty() is_reconciliation = BooleanProperty(default=False) day_index = IntegerProperty() day_note = StringProperty( ) #if there's something for that particular day, then it'll be here day_slot = IntegerProperty( ) #new addition, if there's a slot for the day label, then retain it note = StringProperty( ) #this is for the overall note for that submission, will exist on the anchor date @classmethod def wrap(cls, obj): ints = ['dose_number', 'total_doses', 'day_index', 'day_slot'] for prop_name in ints: val = obj.get(prop_name) if val and isinstance(val, basestring): obj[prop_name] = int(val) return super(CObservation, cls).wrap(obj) @property def obs_score(self): """Gets the relative score of the observation. """ if self.method == "direct": return 3 if self.method == "pillbox": return 2 if self.method == "self": return 1 @property def adinfo(self): """helper function to concatenate adherence and method to check for conflicts""" return ((self.is_art, self.dose_number, self.total_doses), "%s" % (self.adherence)) def get_time_label(self): """ old style way returns an English time label out of 'Dose', 'Morning', 'Noon', 'Evening', 'Bedtime' """ return TIME_LABEL_LOOKUP[self.total_doses][self.dose_number] @classmethod def get_time_labels(cls, total_doses): return TIME_LABEL_LOOKUP[total_doses] class Meta: app_label = 'pact' def __unicode__(self): return "Obs %s [%s] %d/%d" % (self.observed_date.strftime("%Y-%m-%d"), "ART" if self.is_art else "NonART", self.dose_number + 1, self.total_doses) def __str__(self): return "Obs %s [%s] %d/%d" % (self.observed_date.strftime("%Y-%m-%d"), "ART" if self.is_art else "NonART", self.dose_number + 1, self.total_doses) def __repr__(self): return simplejson.dumps(self.to_json(), indent=4)
class IndicatorDefinition(Document, AdminCRUDDocumentMixin): """ An Indicator Definition defines how to compute the indicator that lives in the namespaced computed_ property of a case or form. """ namespace = StringProperty() domain = StringProperty() slug = StringProperty() version = IntegerProperty() class_path = StringProperty() last_modified = DateTimeProperty() _admin_crud_class = IndicatorAdminCRUDManager _class_path = "corehq.apps.indicators.models" _returns_multiple = False def __init__(self, _d=None, **kwargs): super(IndicatorDefinition, self).__init__(_d, **kwargs) self.class_path = self._class_path def __str__(self): return "\n\n%(class_name)s - Modified %(last_modified)s\n %(slug)s, domain: %(domain)s," \ " version: %(version)s, namespace: %(namespace)s. ID: %(indicator_id)s." % { 'class_name': self.__class__.__name__, 'slug': self.slug, 'domain': self.domain, 'version': self.version, 'namespace': self.namespace, 'last_modified': (self.last_modified.strftime('%m %B %Y at %H:%M') if self.last_modified else "Ages Ago"), 'indicator_id': self._id, } @classmethod def key_properties(cls): """ The ordering of these property names should match the ordering of what's emitted in the first part of the couch views used for fetching these indicators. These views currently are: - indicators/dynamic_indicator_definitions (Couch View Indicator Defs) - indicators/indicator_definitions (Form and Case Indicator Defs) """ return ["namespace", "domain", "slug"] @classmethod def indicator_list_view(cls): return "indicators/indicator_definitions" @classmethod def _generate_couch_key(cls, version=None, reverse=False, **kwargs): key = list() key_prefix = list() for p in cls.key_properties(): k = kwargs.get(p) if k is not None: key_prefix.append(p) key.append(k) key = [" ".join(key_prefix)] + key couch_key = dict(startkey=key, endkey=key+[{}]) if version is None else dict(key=key+[version]) if reverse: return dict(startkey=couch_key.get('endkey'), endkey=couch_key.get('startkey')) return couch_key @classmethod def increment_or_create_unique(cls, namespace, domain, slug=None, version=None, **kwargs): """ If an indicator with the same namespace, domain, and version exists, create a new indicator with the version number incremented. """ couch_key = cls._generate_couch_key( namespace=namespace, domain=domain, slug=slug, reverse=True, **kwargs ) existing_indicator = cls.view( cls.indicator_list_view(), reduce=False, include_docs=True, descending=True, limit=1, **couch_key ).first() if existing_indicator: version = existing_indicator.version + 1 elif version is None: version = 1 new_indicator = cls( version=version, namespace=namespace, domain=domain, slug=slug, **kwargs ) new_indicator.last_modified = datetime.datetime.utcnow() new_indicator.save() return new_indicator @classmethod @memoized def get_current(cls, namespace, domain, slug, version=None, wrap=True, **kwargs): couch_key = cls._generate_couch_key( namespace=namespace, domain=domain, slug=slug, version=version, reverse=True, **kwargs ) results = cache_core.cached_view(cls.get_db(), cls.indicator_list_view(), cache_expire=60*60*6, reduce=False, include_docs=False, descending=True, **couch_key ) doc = results[0] if results else None if wrap and doc: try: doc_class = to_function(doc.get('value', "%s.%s" % (cls._class_path, cls.__name__))) return doc_class.get(doc.get('id')) except Exception as e: logging.error("No matching documents found for indicator %s: %s" % (slug, e)) return None return doc @classmethod def all_slugs(cls, namespace, domain, **kwargs): couch_key = cls._generate_couch_key( namespace=namespace, domain=domain, reverse=True, **kwargs ) couch_key['startkey'][0] = couch_key.get('startkey', [])[0]+' slug' couch_key['endkey'][0] = couch_key.get('endkey', [])[0]+' slug' data = cls.view(cls.indicator_list_view(), group=True, group_level=cls.key_properties().index('slug')+2, descending=True, **couch_key ).all() return [item.get('key',[])[-1] for item in data] @classmethod @memoized def get_all(cls, namespace, domain, version=None, **kwargs): all_slugs = cls.all_slugs(namespace, domain, **kwargs) all_indicators = list() for slug in all_slugs: indicator = cls.get_current(namespace, domain, slug, version=version, **kwargs) if indicator and issubclass(indicator.__class__, cls): all_indicators.append(indicator) return all_indicators @classmethod def get_all_of_type(cls, namespace, domain, show_only_current=False): key = ["type", namespace, domain, cls.__name__] indicators = cls.view( cls.indicator_list_view(), reduce=False, include_docs=True, startkey=key, endkey=key+[{}] ).all() unique = {} for ind in indicators: if ind.base_doc == "CaseIndicatorDefinition": specific_doc = ind.case_type elif ind.base_doc == "FormIndicatorDefinition": specific_doc = ind.xmlns else: specific_doc = "couch" unique["%s.%s.%s" % (ind.slug, ind.namespace, specific_doc)] = ind return unique.values() @classmethod def get_nice_name(cls): return "Indicator Definition"
class Comment(Document): author = StringProperty() content = StringProperty() date = DateTimeProperty(default=datetime.utcnow) post = StringProperty()
class ComputedDocumentMixin(DocumentSchema): """ Use this mixin for things like CommCareCase or XFormInstance documents that take advantage of indicator definitions. computed_ is namespaced and may look like the following for indicators: computed_: { mvp_indicators: { indicator_slug: { version: 1, value: "foo" } } } """ computed_ = DictProperty() computed_modified_on_ = DateTimeProperty() # a flag for the indicator pillows so that there aren't any Document Update Conflicts initial_processing_complete = BooleanProperty(default=False) def update_indicator(self, indicator_def, save_on_update=True, logger=None): existing_indicators = self.computed_.get(indicator_def.namespace, {}) updated_indicators, is_update = indicator_def.update_computed_namespace( existing_indicators, self) if is_update: self.computed_[indicator_def.namespace] = updated_indicators self.computed_modified_on_ = datetime.datetime.utcnow() if logger: logger.info( "[INDICATOR %(namespace)s %(domain)s] Updating %(indicator_type)s:%(indicator_slug)s " "in %(document_type)s [%(document_id)s]." % { 'namespace': indicator_def.namespace, 'domain': indicator_def.domain, 'indicator_type': indicator_def.__class__.__name__, 'indicator_slug': indicator_def.slug, 'document_type': self.__class__.__name__, 'document_id': self._id, }) if save_on_update: self.save(**get_safe_write_kwargs()) if logger: logger.debug("Saved %s." % self._id) return is_update def update_indicators_in_bulk(self, indicators, save_on_update=True, logger=None): is_update = False for indicator in indicators: try: if self.update_indicator(indicator, save_on_update=False, logger=logger): is_update = True except Exception: logger.exception( "[INDICATOR %(namespace)s %(domain)s] Failed to update %(indicator_type)s: " "%(indicator_slug)s in %(document_type)s [%(document_id)s]." % { 'namespace': indicator.namespace, 'domain': indicator.domain, 'indicator_type': indicator.__class__.__name__, 'indicator_slug': indicator.slug, 'document_type': self.__class__.__name__, 'document_id': self._id, }) if is_update and save_on_update: try: self.save(**get_safe_write_kwargs()) if logger: logger.info("Saved %s." % self._id) except ResourceConflict: logger.error( "[INDICATOR %(domain)s] Resource conflict failed to save document indicators for " "%(document_type)s [%(document_id)s]." % { 'domain': self.domain, 'document_type': self.__class__.__name__, 'document_id': self._id, }) return is_update
class CouchDocument(Document): """Main CouchDB document format model Usually a representation of DMS Document() stored in CouchDB""" id = StringProperty() metadata_doc_type_rule_id = StringProperty(default="") metadata_user_id = StringProperty(default="") metadata_user_name = StringProperty(default="") metadata_created_date = DateTimeProperty(default=datetime.utcnow()) metadata_description = StringProperty(default="") tags = ListProperty(default=[]) mdt_indexes = DictProperty(default={}) search_keywords = ListProperty(default=[]) revisions = DictProperty(default={}) index_revisions = DictProperty(default={}) class Meta: app_label = "dmscouch" def populate_from_dms(self, user, document): """Populates CouchDB Document fields from DMS Document object. @param user: django internal User() object instance @param document: DMS Document() instance""" # Setting document ID, based on filename. Using stripped (pure docrule regex readable) filename if possible. if document.get_code(): self.id = document.get_code() self._doc['_id'] = self.id self.metadata_doc_type_rule_id = str(document.docrule.pk) # setting provided user name/id if "metadata_user_name" in document.db_info and "metadata_user_id" in document.db_info: self.metadata_user_name = document.db_info["metadata_user_name"] self.metadata_user_id = document.db_info["metadata_user_id"] else: self.set_user_name_for_couch(user) self.set_doc_date(document) # adding description if exists if "description" in document.db_info: self.metadata_description = document.db_info["description"] else: self.metadata_description = "" self.tags = document.tags # populating secondary indexes if document.db_info: db_info = document.db_info # trying to cleanup irrelevant fields if exist... # (Bug #829 Files Secondary indexes contain username and user PK) del_keys = [] for key in db_info: if key in [ "date", "description", "metadata_user_name", "metadata_user_id", "mdt_indexes", "metadata_created_date", "metadata_doc_type_rule_id", "tags", ]: del_keys.append(key) for key in del_keys: del db_info[key] self.mdt_indexes = db_info self.search_keywords = [] # TODO: not implemented yet self.revisions = document.get_file_revisions_data() if document.index_revisions: self.index_revisions = document.index_revisions def populate_into_dms(self, document): """Updates DMS Document object with CouchDB fields data. @param document: DMS Document() instance""" document.set_file_revisions_data(self.revisions) if self.tags: document.tags = self.tags document.code = self.id document.db_info = self.construct_db_info() if 'index_revisions' in self: document.index_revisions = self.index_revisions if 'deleted' in self: if self['deleted'] == 'deleted': document.marked_deleted = True return document def construct_db_info(self, db_info=None): """Method to populate additional database info from CouchDB into DMS Document object. @param db_info: a set of CouchDB metadata info, extracted from CouchDB document""" if not db_info: db_info = {} db_info["description"] = self.metadata_description db_info["tags"] = self.tags db_info["metadata_doc_type_rule_id"] = self.metadata_doc_type_rule_id db_info["metadata_user_id"] = self.metadata_user_id db_info["metadata_user_name"] = self.metadata_user_name db_info["metadata_created_date"] = self.metadata_created_date db_info["mdt_indexes"] = self.mdt_indexes return db_info def construct_index_revision_dict(self, old_couchdoc_id=False): """Constructs current indexes revision and export into result dict @param old_couchdoc_id: either to include or not old document name into metadata list mus contain old couchdoc name""" current_index_data = { 'metadata_created_date': self.metadata_created_date, 'metadata_description': self.metadata_description, 'metadata_user_id': self.metadata_user_id, 'metadata_user_name': self.metadata_user_name, 'mdt_indexes': self.mdt_indexes, } if old_couchdoc_id: current_index_data['metadata_old_id'] = old_couchdoc_id return current_index_data def set_doc_date(self, document): """Unifies DB storage of date object received from document. @param document: DMS Document() instance""" doc_date = None # trying to get date from db_info dict first if 'date' in document.db_info: doc_date = datetime.strptime(str(document.db_info["date"]), settings.DATE_FORMAT) if not doc_date and document.revision: # Setting document current revision metadata date, except not exists using now() instead. revision = unicode(document.revision) if revision in document.file_revision_data: rev_dict = document.file_revision_data[revision] if 'created_date' in rev_dict[revision]: tmp_date = rev_dict[revision][u'created_date'] doc_date = datetime.strptime(tmp_date, "%Y-%m-%d %H:%M:%S") if not doc_date: doc_date = datetime.utcnow() self.metadata_created_date = doc_date def update_indexes_revision(self, document): """Updates CouchDB document with new revision of indexing data. @param document: DMS Document() instance Old indexing data is stored in revision. E.g.: Document only created: couchdoc.index_revisions = None Document updated once: couchdoc.index_revisions = { '1': { ... }, } Document updated again and farther: couchdoc.index_revisions = { '1': { ... }, '2': { ... }, ... } This method handles storing of indexing data changes (old one's) are stored into revisions. New data are populated into couchdoc thus making them current. """ if document.new_indexes: # Creating clean self.mdt_indexes secondary_indexes = {} for secondary_index_name, secondary_index_value in document.new_indexes.iteritems( ): if not secondary_index_name in [ 'description', 'metadata_user_name', 'metadata_user_id', ]: # Converting date format to couch if secondary index is DMS date type try: datetime.strptime(secondary_index_value, settings.DATE_FORMAT) secondary_indexes[ secondary_index_name] = str_date_to_couch( secondary_index_value) except ValueError: secondary_indexes[ secondary_index_name] = secondary_index_value pass # Only for update without docrule change (it makes it's own indexes backup) if not document.old_docrule: # Storing current index data into new revision if not 'index_revisions' in self: # Creating index_revisions initial data dictionary. self.index_revisions = { '1': self.construct_index_revision_dict(), } else: # Appending new document indexes revision to revisions dict new_revision = self.index_revisions.__len__() + 1 self.index_revisions[ new_revision] = self.construct_index_revision_dict() # Populating self with new provided data self.mdt_indexes = secondary_indexes # Making desc and user data optional, taking them from current user if 'description' in document.new_indexes: self.metadata_description = document.new_indexes['description'] else: self.metadata_description = 'N/A' if 'metadata_user_id' in document.new_indexes: self.metadata_user_id = document.new_indexes[ 'metadata_user_id'] else: self.metadata_user_id = unicode(document.user.id) if 'metadata_user_name' in document.new_indexes: self.metadata_user_id = document.new_indexes[ 'metadata_user_name'] else: self.metadata_user_name = document.user.username return document def update_file_revisions_metadata(self, document): """ Stores files revision data into CouchDB from DMS document object @param document: DMS Document() instance E.g.: Before this function: couchdoc.revisions = { '1': { ... }, } After: couchdoc.revisions = { '1': { ... }, '2': { ... }, } (Loaded from a Document() object) """ self.revisions = document.get_file_revisions_data() def migrate_metadata_for_docrule(self, document, old_couchdoc): """Moving a CouchDB document into another file @param document: DMS Document() instance @param old_couchdoc: CouchDocument instance""" if not old_couchdoc.index_revisions: # Creating index_revisions initial data dictionary. self.index_revisions = { '1': old_couchdoc.construct_index_revision_dict(old_couchdoc.id), } else: self.index_revisions = old_couchdoc.index_revisions # Appending new document indexes revision to revisions dict new_revision = self.index_revisions.__len__() + 1 self.index_revisions[str( new_revision)] = old_couchdoc.construct_index_revision_dict( old_couchdoc.id) self.revisions = document.get_file_revisions_data() self.metadata_description = old_couchdoc.metadata_description if document.user: self.set_user_name_for_couch(document.user) else: self.metadata_user_id = old_couchdoc.metadata_user_id self.metadata_user_name = old_couchdoc.metadata_user_name self.metadata_description = old_couchdoc.metadata_description self.metadata_created_date = old_couchdoc.metadata_created_date self.search_keywords = old_couchdoc.search_keywords self.tags = old_couchdoc.tags self.metadata_doc_type_rule_id = str(document.docrule.pk) self.id = document.get_filename() def set_user_name_for_couch(self, user): """ user name/id from Django user @param user: django internal User() object instance""" self.metadata_user_id = str(user.pk) if user.first_name: self.metadata_user_name = user.first_name + u' ' + user.last_name else: self.metadata_user_name = user.username
class Domain(Document, HQBillingDomainMixin, SnapshotMixin): """Domain is the highest level collection of people/stuff in the system. Pretty much everything happens at the domain-level, including user membership, permission to see data, reports, charts, etc.""" name = StringProperty() is_active = BooleanProperty() is_public = BooleanProperty(default=False) date_created = DateTimeProperty() default_timezone = StringProperty(default=getattr(settings, "TIME_ZONE", "UTC")) case_sharing = BooleanProperty(default=False) organization = StringProperty() hr_name = StringProperty() # the human-readable name for this project within an organization eula = SchemaProperty(LicenseAgreement) creating_user = StringProperty() # username of the user who created this domain # domain metadata project_type = StringProperty() # e.g. MCH, HIV customer_type = StringProperty() # plus, full, etc. is_test = BooleanProperty(default=True) description = StringProperty() short_description = StringProperty() is_shared = BooleanProperty(default=False) commtrack_enabled = BooleanProperty(default=False) call_center_config = SchemaProperty(CallCenterProperties) case_display = SchemaProperty(CaseDisplaySettings) # CommConnect settings survey_management_enabled = BooleanProperty(default=False) sms_case_registration_enabled = BooleanProperty(default=False) # Whether or not a case can register via sms sms_case_registration_type = StringProperty() # Case type to apply to cases registered via sms sms_case_registration_owner_id = StringProperty() # Owner to apply to cases registered via sms sms_case_registration_user_id = StringProperty() # Submitting user to apply to cases registered via sms sms_mobile_worker_registration_enabled = BooleanProperty(default=False) # Whether or not a mobile worker can register via sms default_sms_backend_id = StringProperty() # exchange/domain copying stuff is_snapshot = BooleanProperty(default=False) is_approved = BooleanProperty(default=False) snapshot_time = DateTimeProperty() published = BooleanProperty(default=False) license = StringProperty(choices=LICENSES, default='cc') title = StringProperty() cda = SchemaProperty(LicenseAgreement) multimedia_included = BooleanProperty(default=True) downloads = IntegerProperty(default=0) author = StringProperty() phone_model = StringProperty() attribution_notes = StringProperty() publisher = StringProperty(choices=["organization", "user"], default="user") yt_id = StringProperty() deployment = SchemaProperty(Deployment) image_path = StringProperty() image_type = StringProperty() migrations = SchemaProperty(DomainMigrations) cached_properties = DictProperty() internal = SchemaProperty(InternalProperties) # extra user specified properties tags = StringListProperty() area = StringProperty(choices=AREA_CHOICES) sub_area = StringProperty(choices=SUB_AREA_CHOICES) launch_date = DateTimeProperty # to be eliminated from projects and related documents when they are copied for the exchange _dirty_fields = ('admin_password', 'admin_password_charset', 'city', 'country', 'region', 'customer_type') @classmethod def wrap(cls, data): # for domains that still use original_doc should_save = False if 'original_doc' in data: original_doc = data['original_doc'] del data['original_doc'] should_save = True if original_doc: original_doc = Domain.get_by_name(original_doc) data['copy_history'] = [original_doc._id] # for domains that have a public domain license if 'license' in data: if data.get("license", None) == "public": data["license"] = "cc" should_save = True # if not 'creating_user' in data: # should_save = True # from corehq.apps.users.models import CouchUser # admins = CouchUser.view("users/admins_by_domain", key=data["name"], reduce=False, include_docs=True).all() # if len(admins) == 1: # data["creating_user"] = admins[0].username # else: # data["creating_user"] = None if 'slug' in data and data["slug"]: data["hr_name"] = data["slug"] del data["slug"] self = super(Domain, cls).wrap(data) if self.get_id: self.apply_migrations() if should_save: self.save() return self @staticmethod def active_for_user(user, is_active=True): if isinstance(user, AnonymousUser): return [] from corehq.apps.users.models import CouchUser if isinstance(user, CouchUser): couch_user = user else: couch_user = CouchUser.from_django_user(user) if couch_user: domain_names = couch_user.get_domains() return Domain.view("domain/by_status", keys=[[is_active, d] for d in domain_names], reduce=False, include_docs=True, stale=settings.COUCH_STALE_QUERY, ).all() else: return [] @classmethod def field_by_prefix(cls, field, prefix='', is_approved=True): # unichr(0xfff8) is something close to the highest character available res = cls.view("domain/fields_by_prefix", group=True, startkey=[field, is_approved, prefix], endkey=[field, is_approved, "%s%c" % (prefix, unichr(0xfff8)), {}]) vals = [(d['value'], d['key'][2]) for d in res] vals.sort(reverse=True) return [(v[1], v[0]) for v in vals] @classmethod def get_by_field(cls, field, value, is_approved=True): return cls.view('domain/fields_by_prefix', key=[field, is_approved, value], reduce=False, include_docs=True).all() def apply_migrations(self): self.migrations.apply(self) @staticmethod def all_for_user(user): if not hasattr(user,'get_profile'): # this had better be an anonymous user return [] from corehq.apps.users.models import CouchUser couch_user = CouchUser.from_django_user(user) if couch_user: domain_names = couch_user.get_domains() return Domain.view("domain/domains", keys=domain_names, reduce=False, include_docs=True).all() else: return [] def add(self, model_instance, is_active=True): """ Add something to this domain, through the generic relation. Returns the created membership object """ # Add membership info to Couch couch_user = model_instance.get_profile().get_couch_user() couch_user.add_domain_membership(self.name) couch_user.save() def applications(self): from corehq.apps.app_manager.models import ApplicationBase return ApplicationBase.view('app_manager/applications_brief', startkey=[self.name], endkey=[self.name, {}]).all() def full_applications(self, include_builds=True): from corehq.apps.app_manager.models import Application, RemoteApp WRAPPERS = {'Application': Application, 'RemoteApp': RemoteApp} def wrap_application(a): return WRAPPERS[a['doc']['doc_type']].wrap(a['doc']) if include_builds: startkey = [self.name] endkey = [self.name, {}] else: startkey = [self.name, None] endkey = [self.name, None, {}] return get_db().view('app_manager/applications', startkey=startkey, endkey=endkey, include_docs=True, wrapper=wrap_application).all() @cached_property def versions(self): apps = self.applications() return list(set(a.application_version for a in apps)) @cached_property def has_case_management(self): for app in self.full_applications(): if app.doc_type == 'Application': if app.has_case_management(): return True return False @cached_property def has_media(self): for app in self.full_applications(): if app.doc_type == 'Application' and app.has_media(): return True return False def all_users(self): from corehq.apps.users.models import CouchUser return CouchUser.by_domain(self.name) def has_shared_media(self): return False def recent_submissions(self): from corehq.apps.reports.util import make_form_couch_key key = make_form_couch_key(self.name) res = get_db().view('reports_forms/all_forms', startkey=key+[{}], endkey=key, descending=True, reduce=False, include_docs=False, limit=1).all() if len(res) > 0: # if there have been any submissions in the past 30 days return (datetime.now() <= datetime.strptime(res[0]['value']['submission_time'], "%Y-%m-%dT%H:%M:%SZ") + timedelta(days=30)) else: return False @cached_property def languages(self): apps = self.applications() return set(chain.from_iterable([a.langs for a in apps])) def readable_languages(self): return ', '.join(lang_lookup[lang] or lang for lang in self.languages()) def __unicode__(self): return self.name @classmethod def get_by_name(cls, name, strict=False): if not name: # get_by_name should never be called with name as None (or '', etc) # I fixed the code in such a way that if I raise a ValueError # all tests pass and basic pages load, # but in order not to break anything in the wild, # I'm opting to notify by email if/when this happens # but fall back to the previous behavior of returning None try: raise ValueError('%r is not a valid domain name' % name) except ValueError: if settings.DEBUG: raise else: notify_exception(None, '%r is not a valid domain name' % name) return None extra_args = {'stale': settings.COUCH_STALE_QUERY} if not strict else {} result = cls.view("domain/domains", key=name, reduce=False, include_docs=True, **extra_args ).first() if result is None and not strict: # on the off chance this is a brand new domain, try with strict return cls.get_by_name(name, strict=True) return result @classmethod def get_by_organization(cls, organization): result = cls.view("domain/by_organization", startkey=[organization], endkey=[organization, {}], reduce=False, include_docs=True) return result @classmethod def get_by_organization_and_hrname(cls, organization, hr_name): result = cls.view("domain/by_organization", key=[organization, hr_name], reduce=False, include_docs=True) return result @classmethod def get_or_create_with_name(cls, name, is_active=False): result = cls.view("domain/domains", key=name, reduce=False, include_docs=True).first() if result: return result else: new_domain = Domain(name=name, is_active=is_active, date_created=datetime.utcnow()) new_domain.save(**get_safe_write_kwargs()) return new_domain def password_format(self): """ This was a performance hit, so for now we'll just return 'a' no matter what # If a single application is alphanumeric, return alphanumeric; otherwise, return numeric """ # for app in self.full_applications(): # if hasattr(app, 'profile'): # format = app.profile.get('properties', {}).get('password_format', 'n') # if format == 'a': # return 'a' # return 'n' return 'a' @classmethod def get_all(cls, include_docs=True): return Domain.view("domain/not_snapshots", include_docs=include_docs).all() def case_sharing_included(self): return self.case_sharing or reduce(lambda x, y: x or y, [getattr(app, 'case_sharing', False) for app in self.applications()], False) def save_copy(self, new_domain_name=None, user=None): from corehq.apps.app_manager.models import get_app if new_domain_name is not None and Domain.get_by_name(new_domain_name): return None db = get_db() new_id = db.copy_doc(self.get_id)['id'] if new_domain_name is None: new_domain_name = new_id new_domain = Domain.get(new_id) new_domain.name = new_domain_name new_domain.copy_history = self.get_updated_history() new_domain.is_snapshot = False new_domain.snapshot_time = None new_domain.organization = None # TODO: use current user's organization (?) # reset the cda new_domain.cda.signed = False new_domain.cda.date = None new_domain.cda.type = None new_domain.cda.user_id = None new_domain.cda.user_ip = None for field in self._dirty_fields: if hasattr(new_domain, field): delattr(new_domain, field) for res in db.view('domain/related_to_domain', key=[self.name, True]): if not self.is_snapshot and res['value']['doc_type'] in ('Application', 'RemoteApp'): app = get_app(self.name, res['value']['_id']).get_latest_saved() if app: self.copy_component(app.doc_type, app._id, new_domain_name, user=user) else: self.copy_component(res['value']['doc_type'], res['value']['_id'], new_domain_name, user=user) else: self.copy_component(res['value']['doc_type'], res['value']['_id'], new_domain_name, user=user) new_domain.save() if user: def add_dom_to_user(user): user.add_domain_membership(new_domain_name, is_admin=True) apply_update(user, add_dom_to_user) return new_domain def copy_component(self, doc_type, id, new_domain_name, user=None): from corehq.apps.app_manager.models import import_app from corehq.apps.users.models import UserRole str_to_cls = { 'UserRole': UserRole, } db = get_db() if doc_type in ('Application', 'RemoteApp'): new_doc = import_app(id, new_domain_name) new_doc.copy_history.append(id) else: cls = str_to_cls[doc_type] new_id = db.copy_doc(id)['id'] new_doc = cls.get(new_id) for field in self._dirty_fields: if hasattr(new_doc, field): delattr(new_doc, field) if hasattr(cls, '_meta_fields'): for field in cls._meta_fields: if not field.startswith('_') and hasattr(new_doc, field): delattr(new_doc, field) new_doc.domain = new_domain_name if self.is_snapshot and doc_type == 'Application': new_doc.prepare_multimedia_for_exchange() new_doc.save() return new_doc def save_snapshot(self): if self.is_snapshot: return self else: copy = self.save_copy() if copy is None: return None copy.is_snapshot = True copy.organization = self.organization # i don't think we want this? copy.snapshot_time = datetime.now() del copy.deployment copy.save() return copy def from_snapshot(self): return not self.is_snapshot and self.original_doc is not None def snapshots(self): return Domain.view('domain/snapshots', startkey=[self._id, {}], endkey=[self._id], include_docs=True, descending=True) @memoized def published_snapshot(self): snapshots = self.snapshots().all() for snapshot in snapshots: if snapshot.published: return snapshot return None @classmethod def published_snapshots(cls, include_unapproved=False, page=None, per_page=10): skip = None limit = None if page: skip = (page - 1) * per_page limit = per_page if include_unapproved: return cls.view('domain/published_snapshots', startkey=[False, {}], include_docs=True, descending=True, limit=limit, skip=skip) else: return cls.view('domain/published_snapshots', endkey=[True], include_docs=True, descending=True, limit=limit, skip=skip) @classmethod def snapshot_search(cls, query, page=None, per_page=10): skip = None limit = None if page: skip = (page - 1) * per_page limit = per_page results = get_db().search('domain/snapshot_search', q=json.dumps(query), limit=limit, skip=skip, stale='ok') return map(cls.get, [r['id'] for r in results]), results.total_rows @memoized def get_organization(self): from corehq.apps.orgs.models import Organization return Organization.get_by_name(self.organization) @memoized def organization_title(self): if self.organization: return self.get_organization().title else: return '' def update_deployment(self, **kwargs): self.deployment.update(kwargs) self.save() def update_internal(self, **kwargs): self.internal.update(kwargs) self.save() def display_name(self): if self.is_snapshot: return "Snapshot of %s" % self.copied_from.display_name() if self.hr_name and self.organization: return self.hr_name else: return self.name def long_display_name(self): if self.is_snapshot: return format_html( "Snapshot of {0} > {1}", self.get_organization().title, self.copied_from.display_name() ) if self.organization: return format_html( '{0} > {1}', self.get_organization().title, self.hr_name or self.name ) else: return self.name __str__ = long_display_name def get_license_display(self): return LICENSES.get(self.license) def copies(self): return Domain.view('domain/copied_from_snapshot', key=self._id, include_docs=True) def copies_of_parent(self): return Domain.view('domain/copied_from_snapshot', keys=[s._id for s in self.copied_from.snapshots()], include_docs=True) def delete(self): # delete all associated objects db = get_db() related_docs = db.view('domain/related_to_domain', startkey=[self.name], endkey=[self.name, {}], include_docs=True) for doc in related_docs: db.delete_doc(doc['doc']) super(Domain, self).delete() def all_media(self, from_apps=None): #todo add documentation or refactor from corehq.apps.hqmedia.models import CommCareMultimedia dom_with_media = self if not self.is_snapshot else self.copied_from if self.is_snapshot: app_ids = [app.copied_from.get_id for app in self.full_applications()] if from_apps: from_apps = set([a_id for a_id in app_ids if a_id in from_apps]) else: from_apps = app_ids if from_apps: media = [] media_ids = set() apps = [app for app in dom_with_media.full_applications() if app.get_id in from_apps] for app in apps: for _, m in app.get_media_objects(): if m.get_id not in media_ids: media.append(m) media_ids.add(m.get_id) return media return CommCareMultimedia.view('hqmedia/by_domain', key=dom_with_media.name, include_docs=True).all() def most_restrictive_licenses(self, apps_to_check=None): from corehq.apps.hqmedia.utils import most_restrictive licenses = [m.license['type'] for m in self.all_media(from_apps=apps_to_check) if m.license] return most_restrictive(licenses) @classmethod def popular_sort(cls, domains): sorted_list = [] MIN_REVIEWS = 1.0 domains = [(domain, Review.get_average_rating_by_app(domain.copied_from._id), Review.get_num_ratings_by_app(domain.copied_from._id)) for domain in domains] domains = [(domain, avg or 0.0, num or 0) for domain, avg, num in domains] total_average_sum = sum(avg for domain, avg, num in domains) total_average_count = len(domains) if not total_average_count: return [] total_average = (total_average_sum / total_average_count) for domain, average_rating, num_ratings in domains: if num_ratings == 0: sorted_list.append((0.0, domain)) else: weighted_rating = ((num_ratings / (num_ratings + MIN_REVIEWS)) * average_rating + (MIN_REVIEWS / (num_ratings + MIN_REVIEWS)) * total_average) sorted_list.append((weighted_rating, domain)) sorted_list = [domain for weighted_rating, domain in sorted(sorted_list, key=lambda domain: domain[0], reverse=True)] return sorted_list @classmethod def hit_sort(cls, domains): domains = list(domains) domains = sorted(domains, key=lambda domain: domain.downloads, reverse=True) return domains @classmethod def public_deployments(cls): return Domain.view('domain/with_deployment', include_docs=True).all() @classmethod def get_module_by_name(cls, domain_name): """ import and return the python module corresponding to domain_name, or None if it doesn't exist. """ module_name = get_domain_module_map().get(domain_name, domain_name) try: return __import__(module_name) if module_name else None except ImportError: return None @property def commtrack_settings(self): # this import causes some dependency issues so lives in here from corehq.apps.commtrack.models import CommtrackConfig if self.commtrack_enabled: return CommtrackConfig.for_domain(self.name) else: return None def get_case_display(self, case): """Get the properties display definition for a given case""" return self.case_display.case_details.get(case.type) def get_form_display(self, form): """Get the properties display definition for a given XFormInstance""" return self.case_display.form_details.get(form.xmlns)
class Post(Document): author = StringProperty() title = StringProperty() content = StringProperty() date = DateTimeProperty(default=datetime.utcnow)
class Domain(Document, HQBillingDomainMixin, SnapshotMixin): """Domain is the highest level collection of people/stuff in the system. Pretty much everything happens at the domain-level, including user membership, permission to see data, reports, charts, etc.""" name = StringProperty() is_active = BooleanProperty() is_public = BooleanProperty(default=False) date_created = DateTimeProperty() default_timezone = StringProperty( default=getattr(settings, "TIME_ZONE", "UTC")) case_sharing = BooleanProperty(default=False) secure_submissions = BooleanProperty(default=False) ota_restore_caching = BooleanProperty(default=False) cloudcare_releases = StringProperty( choices=['stars', 'nostars', 'default'], default='default') organization = StringProperty() hr_name = StringProperty( ) # the human-readable name for this project within an organization creating_user = StringProperty( ) # username of the user who created this domain # domain metadata project_type = StringProperty() # e.g. MCH, HIV customer_type = StringProperty() # plus, full, etc. is_test = StringProperty(choices=["true", "false", "none"], default="none") description = StringProperty() short_description = StringProperty() is_shared = BooleanProperty(default=False) commtrack_enabled = BooleanProperty(default=False) call_center_config = SchemaProperty(CallCenterProperties) has_careplan = BooleanProperty(default=False) restrict_superusers = BooleanProperty(default=False) location_restriction_for_users = BooleanProperty(default=True) case_display = SchemaProperty(CaseDisplaySettings) # CommConnect settings commconnect_enabled = BooleanProperty(default=False) survey_management_enabled = BooleanProperty(default=False) sms_case_registration_enabled = BooleanProperty( default=False) # Whether or not a case can register via sms sms_case_registration_type = StringProperty( ) # Case type to apply to cases registered via sms sms_case_registration_owner_id = StringProperty( ) # Owner to apply to cases registered via sms sms_case_registration_user_id = StringProperty( ) # Submitting user to apply to cases registered via sms sms_mobile_worker_registration_enabled = BooleanProperty( default=False) # Whether or not a mobile worker can register via sms default_sms_backend_id = StringProperty() use_default_sms_response = BooleanProperty(default=False) default_sms_response = StringProperty() chat_message_count_threshold = IntegerProperty() custom_chat_template = StringProperty( ) # See settings.CUSTOM_CHAT_TEMPLATES custom_case_username = StringProperty( ) # Case property to use when showing the case's name in a chat window # If empty, sms can be sent at any time. Otherwise, only send during # these windows of time. SMS_QUEUE_ENABLED must be True in localsettings # for this be considered. restricted_sms_times = SchemaListProperty(DayTimeWindow) # If empty, this is ignored. Otherwise, the framework will make sure # that during these days/times, no automated outbound sms will be sent # to someone if they have sent in an sms within sms_conversation_length # minutes. Outbound sms sent from a user in a chat window, however, will # still be sent. This is meant to prevent chat conversations from being # interrupted by automated sms reminders. # SMS_QUEUE_ENABLED must be True in localsettings for this to be # considered. sms_conversation_times = SchemaListProperty(DayTimeWindow) # In minutes, see above. sms_conversation_length = IntegerProperty(default=10) # Set to True to prevent survey questions and answers form being seen in # SMS chat windows. filter_surveys_from_chat = BooleanProperty(default=False) # The below option only matters if filter_surveys_from_chat = True. # If set to True, invalid survey responses will still be shown in the chat # window, while questions and valid responses will be filtered out. show_invalid_survey_responses_in_chat = BooleanProperty(default=False) # If set to True, if a message is read by anyone it counts as being read by # everyone. Set to False so that a message is only counted as being read # for a user if only that user has read it. count_messages_as_read_by_anyone = BooleanProperty(default=False) # Set to True to allow sending sms and all-label surveys to cases whose # phone number is duplicated with another contact send_to_duplicated_case_numbers = BooleanProperty(default=False) # exchange/domain copying stuff is_snapshot = BooleanProperty(default=False) is_approved = BooleanProperty(default=False) snapshot_time = DateTimeProperty() published = BooleanProperty(default=False) license = StringProperty(choices=LICENSES, default='cc') title = StringProperty() cda = SchemaProperty(LicenseAgreement) multimedia_included = BooleanProperty(default=True) downloads = IntegerProperty( default=0) # number of downloads for this specific snapshot full_downloads = IntegerProperty( default=0) # number of downloads for all snapshots from this domain author = StringProperty() phone_model = StringProperty() attribution_notes = StringProperty() publisher = StringProperty(choices=["organization", "user"], default="user") yt_id = StringProperty() deployment = SchemaProperty(Deployment) image_path = StringProperty() image_type = StringProperty() migrations = SchemaProperty(DomainMigrations) cached_properties = DictProperty() internal = SchemaProperty(InternalProperties) dynamic_reports = SchemaListProperty(DynamicReportSet) # extra user specified properties tags = StringListProperty() area = StringProperty(choices=AREA_CHOICES) sub_area = StringProperty(choices=SUB_AREA_CHOICES) launch_date = DateTimeProperty # to be eliminated from projects and related documents when they are copied for the exchange _dirty_fields = ('admin_password', 'admin_password_charset', 'city', 'country', 'region', 'customer_type') @property def domain_type(self): """ The primary type of this domain. Used to determine site-specific branding. """ if self.commtrack_enabled: return 'commtrack' else: return 'commcare' @classmethod def wrap(cls, data): # for domains that still use original_doc should_save = False if 'original_doc' in data: original_doc = data['original_doc'] del data['original_doc'] should_save = True if original_doc: original_doc = Domain.get_by_name(original_doc) data['copy_history'] = [original_doc._id] # for domains that have a public domain license if 'license' in data: if data.get("license", None) == "public": data["license"] = "cc" should_save = True if 'slug' in data and data["slug"]: data["hr_name"] = data["slug"] del data["slug"] if 'is_test' in data and isinstance(data["is_test"], bool): data["is_test"] = "true" if data["is_test"] else "false" should_save = True if 'cloudcare_releases' not in data: data['cloudcare_releases'] = 'nostars' # legacy default setting self = super(Domain, cls).wrap(data) if self.deployment is None: self.deployment = Deployment() if self.get_id: self.apply_migrations() if should_save: self.save() return self @staticmethod def active_for_user(user, is_active=True): if isinstance(user, AnonymousUser): return [] from corehq.apps.users.models import CouchUser if isinstance(user, CouchUser): couch_user = user else: couch_user = CouchUser.from_django_user(user) if couch_user: domain_names = couch_user.get_domains() return cache_core.cached_view(Domain.get_db(), "domain/by_status", keys=[[is_active, d] for d in domain_names], reduce=False, include_docs=True, wrapper=Domain.wrap) else: return [] @classmethod def field_by_prefix(cls, field, prefix='', is_approved=True): # unichr(0xfff8) is something close to the highest character available res = cls.view( "domain/fields_by_prefix", group=True, startkey=[field, is_approved, prefix], endkey=[field, is_approved, "%s%c" % (prefix, unichr(0xfff8)), {}]) vals = [(d['value'], d['key'][2]) for d in res] vals.sort(reverse=True) return [(v[1], v[0]) for v in vals] @classmethod def get_by_field(cls, field, value, is_approved=True): return cls.view('domain/fields_by_prefix', key=[field, is_approved, value], reduce=False, include_docs=True).all() def apply_migrations(self): self.migrations.apply(self) @staticmethod def all_for_user(user): if not hasattr(user, 'get_profile'): # this had better be an anonymous user return [] from corehq.apps.users.models import CouchUser couch_user = CouchUser.from_django_user(user) if couch_user: domain_names = couch_user.get_domains() return Domain.view("domain/domains", keys=domain_names, reduce=False, include_docs=True).all() else: return [] def add(self, model_instance, is_active=True): """ Add something to this domain, through the generic relation. Returns the created membership object """ # Add membership info to Couch couch_user = model_instance.get_profile().get_couch_user() couch_user.add_domain_membership(self.name) couch_user.save() def applications(self): from corehq.apps.app_manager.models import ApplicationBase return ApplicationBase.view('app_manager/applications_brief', startkey=[self.name], endkey=[self.name, {}]).all() def full_applications(self, include_builds=True): from corehq.apps.app_manager.models import Application, RemoteApp WRAPPERS = {'Application': Application, 'RemoteApp': RemoteApp} def wrap_application(a): return WRAPPERS[a['doc']['doc_type']].wrap(a['doc']) if include_builds: startkey = [self.name] endkey = [self.name, {}] else: startkey = [self.name, None] endkey = [self.name, None, {}] return get_db().view('app_manager/applications', startkey=startkey, endkey=endkey, include_docs=True, wrapper=wrap_application).all() @cached_property def versions(self): apps = self.applications() return list(set(a.application_version for a in apps)) @cached_property def has_case_management(self): for app in self.full_applications(): if app.doc_type == 'Application': if app.has_case_management(): return True return False @cached_property def has_media(self): for app in self.full_applications(): if app.doc_type == 'Application' and app.has_media(): return True return False @property def use_cloudcare_releases(self): return self.cloudcare_releases != 'nostars' def all_users(self): from corehq.apps.users.models import CouchUser return CouchUser.by_domain(self.name) def has_shared_media(self): return False def recent_submissions(self): from corehq.apps.reports.util import make_form_couch_key key = make_form_couch_key(self.name) res = get_db().view('reports_forms/all_forms', startkey=key + [{}], endkey=key, descending=True, reduce=False, include_docs=False, limit=1).all() if len(res ) > 0: # if there have been any submissions in the past 30 days return (datetime.now() <= datetime.strptime(res[0]['key'][2], "%Y-%m-%dT%H:%M:%SZ") + timedelta(days=30)) else: return False @cached_property def languages(self): apps = self.applications() return set(chain.from_iterable([a.langs for a in apps])) def readable_languages(self): return ', '.join(lang_lookup[lang] or lang for lang in self.languages()) def __unicode__(self): return self.name @classmethod def get_by_name(cls, name, strict=False): if not name: # get_by_name should never be called with name as None (or '', etc) # I fixed the code in such a way that if I raise a ValueError # all tests pass and basic pages load, # but in order not to break anything in the wild, # I'm opting to notify by email if/when this happens # but fall back to the previous behavior of returning None try: raise ValueError('%r is not a valid domain name' % name) except ValueError: if settings.DEBUG: raise else: notify_exception(None, '%r is not a valid domain name' % name) return None cache_key = _domain_cache_key(name) MISSING = object() res = cache.get(cache_key, MISSING) if res != MISSING: return res else: domain = cls._get_by_name(name, strict) # 30 mins, so any unforeseen invalidation bugs aren't too bad. cache.set(cache_key, domain, 30 * 60) return domain @classmethod def _get_by_name(cls, name, strict=False): extra_args = { 'stale': settings.COUCH_STALE_QUERY } if not strict else {} db = cls.get_db() res = cache_core.cached_view(db, "domain/domains", key=name, reduce=False, include_docs=True, wrapper=cls.wrap, force_invalidate=strict, **extra_args) if len(res) > 0: result = res[0] else: result = None if result is None and not strict: # on the off chance this is a brand new domain, try with strict return cls.get_by_name(name, strict=True) return result @classmethod def get_by_organization(cls, organization): result = cache_core.cached_view(cls.get_db(), "domain/by_organization", startkey=[organization], endkey=[organization, {}], reduce=False, include_docs=True, wrapper=cls.wrap) from corehq.apps.accounting.utils import domain_has_privilege from corehq import privileges result = filter( lambda x: domain_has_privilege(x.name, privileges. CROSS_PROJECT_REPORTS), result) return result @classmethod def get_by_organization_and_hrname(cls, organization, hr_name): result = cls.view("domain/by_organization", key=[organization, hr_name], reduce=False, include_docs=True) return result @classmethod def get_or_create_with_name(cls, name, is_active=False, secure_submissions=True): result = cls.view("domain/domains", key=name, reduce=False, include_docs=True).first() if result: return result else: new_domain = Domain( name=name, is_active=is_active, date_created=datetime.utcnow(), secure_submissions=secure_submissions, ) new_domain.migrations = DomainMigrations( has_migrated_permissions=True) new_domain.save(**get_safe_write_kwargs()) return new_domain def password_format(self): """ This was a performance hit, so for now we'll just return 'a' no matter what If a single application is alphanumeric, return alphanumeric; otherwise, return numeric """ return 'a' @classmethod def get_all(cls, include_docs=True): # todo: this should use iter_docs return Domain.view("domain/not_snapshots", include_docs=include_docs).all() def case_sharing_included(self): return self.case_sharing or reduce(lambda x, y: x or y, [ getattr(app, 'case_sharing', False) for app in self.applications() ], False) def save(self, **params): super(Domain, self).save(**params) cache.delete(_domain_cache_key(self.name)) from corehq.apps.domain.signals import commcare_domain_post_save results = commcare_domain_post_save.send_robust(sender='domain', domain=self) for result in results: # Second argument is None if there was no error if result[1]: notify_exception( None, message="Error occured during domain post_save %s: %s" % (self.name, str(result[1]))) def save_copy(self, new_domain_name=None, user=None, ignore=None): from corehq.apps.app_manager.models import get_app from corehq.apps.reminders.models import CaseReminderHandler ignore = ignore if ignore is not None else [] if new_domain_name is not None and Domain.get_by_name(new_domain_name): return None db = get_db() new_id = db.copy_doc(self.get_id)['id'] if new_domain_name is None: new_domain_name = new_id new_domain = Domain.get(new_id) new_domain.name = new_domain_name new_domain.copy_history = self.get_updated_history() new_domain.is_snapshot = False new_domain.snapshot_time = None new_domain.organization = None # TODO: use current user's organization (?) # reset stuff new_domain.cda.signed = False new_domain.cda.date = None new_domain.cda.type = None new_domain.cda.user_id = None new_domain.cda.user_ip = None new_domain.is_test = "none" new_domain.internal = InternalProperties() new_domain.creating_user = user.username if user else None for field in self._dirty_fields: if hasattr(new_domain, field): delattr(new_domain, field) new_comps = {} # a mapping of component's id to it's copy for res in db.view('domain/related_to_domain', key=[self.name, True]): if not self.is_snapshot and res['value']['doc_type'] in ( 'Application', 'RemoteApp'): app = get_app(self.name, res['value']['_id']).get_latest_saved() if app: comp = self.copy_component(app.doc_type, app._id, new_domain_name, user=user) else: comp = self.copy_component(res['value']['doc_type'], res['value']['_id'], new_domain_name, user=user) elif res['value']['doc_type'] not in ignore: comp = self.copy_component(res['value']['doc_type'], res['value']['_id'], new_domain_name, user=user) else: comp = None if comp: new_comps[res['value']['_id']] = comp new_domain.save() if user: def add_dom_to_user(user): user.add_domain_membership(new_domain_name, is_admin=True) apply_update(user, add_dom_to_user) def update_events(handler): """ Change the form_unique_id to the proper form for each event in a newly copied CaseReminderHandler """ from corehq.apps.app_manager.models import FormBase for event in handler.events: if not event.form_unique_id: continue form = FormBase.get_form(event.form_unique_id) form_app = form.get_app() m_index, f_index = form_app.get_form_location(form.unique_id) form_copy = new_comps[form_app._id].get_module( m_index).get_form(f_index) event.form_unique_id = form_copy.unique_id def update_for_copy(handler): handler.active = False update_events(handler) if 'CaseReminderHandler' not in ignore: for handler in CaseReminderHandler.get_handlers(new_domain_name): apply_update(handler, update_for_copy) return new_domain def reminder_should_be_copied(self, handler): from corehq.apps.reminders.models import ON_DATETIME return (handler.start_condition_type != ON_DATETIME and handler.user_group_id is None) def copy_component(self, doc_type, id, new_domain_name, user=None): from corehq.apps.app_manager.models import import_app from corehq.apps.users.models import UserRole from corehq.apps.reminders.models import CaseReminderHandler str_to_cls = { 'UserRole': UserRole, 'CaseReminderHandler': CaseReminderHandler, } db = get_db() if doc_type in ('Application', 'RemoteApp'): new_doc = import_app(id, new_domain_name) new_doc.copy_history.append(id) else: cls = str_to_cls[doc_type] if doc_type == 'CaseReminderHandler': cur_doc = cls.get(id) if not self.reminder_should_be_copied(cur_doc): return None new_id = db.copy_doc(id)['id'] new_doc = cls.get(new_id) for field in self._dirty_fields: if hasattr(new_doc, field): delattr(new_doc, field) if hasattr(cls, '_meta_fields'): for field in cls._meta_fields: if not field.startswith('_') and hasattr(new_doc, field): delattr(new_doc, field) new_doc.domain = new_domain_name if self.is_snapshot and doc_type == 'Application': new_doc.prepare_multimedia_for_exchange() new_doc.save() return new_doc def save_snapshot(self, ignore=None): if self.is_snapshot: return self else: copy = self.save_copy(ignore=ignore) if copy is None: return None copy.is_snapshot = True copy.snapshot_time = datetime.now() del copy.deployment copy.save() return copy def from_snapshot(self): return not self.is_snapshot and self.original_doc is not None def snapshots(self): return Domain.view('domain/snapshots', startkey=[self._id, {}], endkey=[self._id], include_docs=True, reduce=False, descending=True) @memoized def published_snapshot(self): snapshots = self.snapshots().all() for snapshot in snapshots: if snapshot.published: return snapshot return None @classmethod def published_snapshots(cls, include_unapproved=False, page=None, per_page=10): skip = None limit = None if page: skip = (page - 1) * per_page limit = per_page if include_unapproved: return cls.view('domain/published_snapshots', startkey=[False, {}], include_docs=True, descending=True, limit=limit, skip=skip) else: return cls.view('domain/published_snapshots', endkey=[True], include_docs=True, descending=True, limit=limit, skip=skip) @classmethod def snapshot_search(cls, query, page=None, per_page=10): skip = None limit = None if page: skip = (page - 1) * per_page limit = per_page results = get_db().search( 'domain/snapshot_search', q=json.dumps(query), limit=limit, skip=skip, #stale='ok', ) return map(cls.get, [r['id'] for r in results]), results.total_rows @memoized def get_organization(self): from corehq.apps.orgs.models import Organization return Organization.get_by_name(self.organization) @memoized def organization_title(self): if self.organization: return self.get_organization().title else: return '' def update_deployment(self, **kwargs): self.deployment.update(kwargs) self.save() def update_internal(self, **kwargs): self.internal.update(kwargs) self.save() def display_name(self): if self.is_snapshot: return "Snapshot of %s" % self.copied_from.display_name() if self.hr_name and self.organization: return self.hr_name else: return self.name def long_display_name(self): if self.is_snapshot: return format_html("Snapshot of {0} > {1}", self.get_organization().title, self.copied_from.display_name()) if self.organization: return format_html('{0} > {1}', self.get_organization().title, self.hr_name or self.name) else: return self.name __str__ = long_display_name def get_license_display(self): return LICENSES.get(self.license) def copies(self): return Domain.view('domain/copied_from_snapshot', key=self._id, include_docs=True) def copies_of_parent(self): return Domain.view('domain/copied_from_snapshot', keys=[s._id for s in self.copied_from.snapshots()], include_docs=True) def delete(self): # delete all associated objects db = get_db() related_docs = db.view('domain/related_to_domain', startkey=[self.name], endkey=[self.name, {}], include_docs=True) for doc in related_docs: db.delete_doc(doc['doc']) super(Domain, self).delete() def all_media(self, from_apps=None): #todo add documentation or refactor from corehq.apps.hqmedia.models import CommCareMultimedia dom_with_media = self if not self.is_snapshot else self.copied_from if self.is_snapshot: app_ids = [ app.copied_from.get_id for app in self.full_applications() ] if from_apps: from_apps = set( [a_id for a_id in app_ids if a_id in from_apps]) else: from_apps = app_ids if from_apps: media = [] media_ids = set() apps = [ app for app in dom_with_media.full_applications() if app.get_id in from_apps ] for app in apps: if app.doc_type != 'Application': continue for _, m in app.get_media_objects(): if m.get_id not in media_ids: media.append(m) media_ids.add(m.get_id) return media return CommCareMultimedia.view('hqmedia/by_domain', key=dom_with_media.name, include_docs=True).all() def most_restrictive_licenses(self, apps_to_check=None): from corehq.apps.hqmedia.utils import most_restrictive licenses = [ m.license['type'] for m in self.all_media(from_apps=apps_to_check) if m.license ] return most_restrictive(licenses) @classmethod def popular_sort(cls, domains): sorted_list = [] MIN_REVIEWS = 1.0 domains = [(domain, Review.get_average_rating_by_app(domain.copied_from._id), Review.get_num_ratings_by_app(domain.copied_from._id)) for domain in domains] domains = [(domain, avg or 0.0, num or 0) for domain, avg, num in domains] total_average_sum = sum(avg for domain, avg, num in domains) total_average_count = len(domains) if not total_average_count: return [] total_average = (total_average_sum / total_average_count) for domain, average_rating, num_ratings in domains: if num_ratings == 0: sorted_list.append((0.0, domain)) else: weighted_rating = ( (num_ratings / (num_ratings + MIN_REVIEWS)) * average_rating + (MIN_REVIEWS / (num_ratings + MIN_REVIEWS)) * total_average) sorted_list.append((weighted_rating, domain)) sorted_list = [ domain for weighted_rating, domain in sorted( sorted_list, key=lambda domain: domain[0], reverse=True) ] return sorted_list @classmethod def hit_sort(cls, domains): domains = list(domains) domains = sorted(domains, key=lambda domain: domain.download_count, reverse=True) return domains @classmethod def public_deployments(cls): return Domain.view('domain/with_deployment', include_docs=True).all() @classmethod def get_module_by_name(cls, domain_name): """ import and return the python module corresponding to domain_name, or None if it doesn't exist. """ from corehq.apps.domain.utils import get_domain_module_map module_name = get_domain_module_map().get(domain_name, domain_name) try: return import_module(module_name) if module_name else None except ImportError: return None @property @memoized def commtrack_settings(self): # this import causes some dependency issues so lives in here from corehq.apps.commtrack.models import CommtrackConfig if self.commtrack_enabled: return CommtrackConfig.for_domain(self.name) else: return None @property def has_custom_logo(self): return (self['_attachments'] and LOGO_ATTACHMENT in self['_attachments']) def get_custom_logo(self): if not self.has_custom_logo: return None return (self.fetch_attachment(LOGO_ATTACHMENT), self['_attachments'][LOGO_ATTACHMENT]['content_type']) def get_case_display(self, case): """Get the properties display definition for a given case""" return self.case_display.case_details.get(case.type) def get_form_display(self, form): """Get the properties display definition for a given XFormInstance""" return self.case_display.form_details.get(form.xmlns) @property def total_downloads(self): """ Returns the total number of downloads from every snapshot created from this domain """ return get_db().view( "domain/snapshots", startkey=[self.get_id], endkey=[self.get_id, {}], reduce=True, include_docs=False, ).one()["value"] @property @memoized def download_count(self): """ Updates and returns the total number of downloads from every sister snapshot. """ if self.is_snapshot: self.full_downloads = self.copied_from.total_downloads return self.full_downloads @property @memoized def published_by(self): from corehq.apps.users.models import CouchUser pb_id = self.cda.user_id return CouchUser.get_by_user_id(pb_id) if pb_id else None @property def name_of_publisher(self): return self.published_by.human_friendly_name if self.published_by else ""