def clean(self):
if self._errors:
return
invalidate('auth_user')
user = authenticate(username=self.cleaned_data["username"],
password=self.cleaned_data["password"])
if user:
try:
profile = user.get_profile()
except Profile.DoesNotExist:
profile = Profile.objects.create_profile(user=user)
if user.is_active and profile.status == True and profile.status_detail.lower(
) == 'active':
self.user = user
else:
raise forms.ValidationError(
_("This account is currently inactive."))
else:
try:
self.user_exists = User.objects.get(
username=self.cleaned_data["username"])
raise forms.ValidationError(
_("The username and/or password you specified are not correct."
))
except User.DoesNotExist:
raise forms.ValidationError(
_("The username and/or password you specified are not correct."
))
return self.cleaned_data
def update_account_status(self):
sub = self.stripe_subscription
# Possible statuses: canceled, past_due, unpaid, active, trialing
if sub.status == "trialing":
self.status = STATUS_FREE_TRIAL
if not self.free_trial_ends_date and hasattr(sub,"trial_end"):
self.free_trial_ends_date = datetime.datetime.fromtimestamp(sub.trial_end)
elif sub.status == "active":
self.status = STATUS_ACTIVE
elif sub.status == "past_due":
self.status = STATUS_ACTIVE_BILLING_ISSUE
elif sub.status == "unpaid":
self.status = STATUS_DEACTIVATED
elif sub.status == "cancelled":
# should never happen
self.status = STATUS_DEACTIVATED
else:
raise Exception, "Unknown subscription status"
if hasattr(sub,"current_period_end"):
# For when Stripe upgrades their API
if type(sub.current_period_end) == type(1):
self.next_billing_date = datetime.datetime.fromtimestamp(sub.current_period_end)
else:
self.next_billing_date = sub.current_period_end
self.last_stripe_update = datetime.datetime.now()
self.save()
jcache.invalidate(Account)
return self
def save(self, commit=False, message=None, user=None):
super(Feature, self).save()
# After save, clear the cached items
for code, name in settings.LANGUAGES:
cache.delete('featured_items_%s' % code)
jc.invalidate('features_feature_translation')
jc.invalidate('Feature')
def handle(self, **options):
print 'Registering plugins...'
register_all_plugins(verbose=True)
# cache invalidation
print 'Invalidating plugins cache...'
query_cache_backend = cache.get_backend()
query_cache_backend.patch()
cache.invalidate(RegisteredPlugin._meta.db_table)
print 'Done.'
def replace(self, queryset, term, replacement, case_sensitive):
if cache:
backend = cache.get_backend()
backend.unpatch()
self.models[queryset.model].replace(queryset, term, replacement,
case_sensitive)
if cache:
backend.patch()
cache.invalidate(queryset.model)
def replace(self, queryset, term, replacement, case_sensitive):
if cache:
backend = cache.get_backend()
backend.unpatch()
self.models[queryset.model].replace(queryset, term, replacement,
case_sensitive)
if cache:
backend.patch()
cache.invalidate(queryset.model)
def export_status(request, task_id, template_name="profiles/export_status.html"):
invalidate("celery_taskmeta")
try:
task = TaskMeta.objects.get(task_id=task_id)
except TaskMeta.DoesNotExist:
task = None
return render_to_response(
template_name, {"task": task, "task_id": task_id, "user_this": None}, context_instance=RequestContext(request)
)
def export_download(request, task_id):
invalidate('celery_taskmeta')
try:
task = TaskMeta.objects.get(task_id=task_id)
except TaskMeta.DoesNotExist:
task = None
if task and task.status == "SUCCESS":
return task.result
else:
raise Http404
def export_check(request, task_id):
invalidate('celery_taskmeta')
try:
task = TaskMeta.objects.get(task_id=task_id)
except TaskMeta.DoesNotExist:
task = None
if task and task.status == "SUCCESS":
return HttpResponse("OK")
else:
return HttpResponse("DNE")
def handle(self, *args, **options):
from tendenci.apps.user_groups.models import Group
invalidate('user_groups_group')
invalidate('auth_group')
tied_auth_group_ids = Group.objects.all().values_list('group',
flat=True)
orphan_auth_groups = AuthGroup.objects.all().exclude(
id__in=tied_auth_group_ids)
for auth_group in orphan_auth_groups:
auth_group.delete()
def handle(self, *args, **options):
from tendenci.apps.user_groups.models import Group
invalidate('user_groups_group')
invalidate('auth_group')
tied_auth_group_ids = Group.objects.all(
).values_list('group',
flat=True)
orphan_auth_groups = AuthGroup.objects.all().exclude(
id__in=tied_auth_group_ids)
for auth_group in orphan_auth_groups:
auth_group.delete()
def status(request, export_id, template_name='exports/export_status.html'):
"""Checks if an export is completed.
"""
if not request.user.is_superuser:
raise Http403
invalidate('exports_export')
export = get_object_or_404(Export, pk=export_id)
return render_to_response(template_name, {
'export': export,
'datetime': datetime,
}, context_instance=RequestContext(request))
def status(request, export_id, template_name='exports/export_status.html'):
"""Checks if an export is completed.
"""
if not request.user.is_superuser:
raise Http403
invalidate('exports_export')
export = get_object_or_404(Export, pk=export_id)
return render_to_response(template_name, {
'export': export,
'datetime': datetime,
},
context_instance=RequestContext(request))
def move_view(self, request, object_id, extra_context=None):
"""The 'move node' admin view for this model."""
opts = self.model._meta
app_label = opts.app_label
obj = self.get_object(request, object_id)
if not self.has_change_permission(request, obj):
raise PermissionDenied
if obj is None:
raise Http404(_('%(name)s object with primary key %(key)r does not exist.') % {'name': force_unicode(opts.verbose_name), 'key': object_id})
if request.POST: # The user has already confirmed the deletion.
form = MoveNodeForm(obj, request.POST)
if form.is_valid():
if "johnny" in django_settings.INSTALLED_APPS:
from johnny.cache import invalidate
invalidate(self.model)
form.save()
self.message_user(request, ugettext('%s has been moved to a new position.') %
obj)
return HttpResponseRedirect("../../")
else:
form = MoveNodeForm(obj)
object_name = force_unicode(opts.verbose_name)
context = {
"title": _('Move: %s') % force_unicode(obj),
"form": form,
"object_name": unicode(obj),
"object": obj,
"opts": opts,
#"root_path": self.admin_site.root_path,
"app_label": app_label,
}
context.update(extra_context or {})
context_instance = template.RequestContext(request, current_app=self.admin_site.name)
return render_to_response(self.delete_confirmation_template or [
"admin/%s/%s/move_node.html" % (app_label, opts.object_name.lower()),
"admin/%s/move_node.html" % app_label,
"admin/move_node.html"
], context, context_instance=context_instance)
def save_basic_info(request, group_id):
group = get_or_404_by_account(Group, request.account, group_id, using='default')
form, rule_formset = _basic_forms(group, request)
success = False
if rule_formset.is_valid():
rule_formset.save()
if form.is_valid():
group = form.save()
jcache.invalidate(GroupSearchProxy)
success = True
form, rule_formset = _basic_forms(group, request, no_data=True)
return {"success":success}
def test_invalidate(self):
"""Test for the module-level invalidation function."""
from Queue import Queue as queue
from testapp.models import Book, Genre, Publisher
from johnny.cache import invalidate
q = base.message_queue()
b = Book.objects.get(id=1)
invalidate(Book)
b = Book.objects.get(id=1)
first, second = q.get_nowait(), q.get_nowait()
self.failUnless(first == second == False)
g = Genre.objects.get(id=1)
p = Publisher.objects.get(id=1)
invalidate('testapp_genre', Publisher)
g = Genre.objects.get(id=1)
p = Publisher.objects.get(id=1)
fg,fp,sg,sp = [q.get() for i in range(4)]
self.failUnless(fg == fp == sg == sp == False)
def forwards(self, orm):
"Write your forwards methods here."
print "Starting update of search proxies. Clearing old proxies..."
cache.clear()
PeopleSearchProxy.objects.all().delete()
print "Organizations cleared."
OrganizationsSearchProxy.objects.all().delete()
print "People cleared."
print "Re-saving organizations..."
OrganizationsSearchProxy.resave_all_organizations(verbose=True)
print "Re-saving people..."
PeopleSearchProxy.resave_all_people(verbose=True)
print "Invalidating cache.."
jcache.invalidate(PeopleSearchProxy)
jcache.invalidate(OrganizationsSearchProxy)
print "Done."
def test_invalidate(self):
"""Test for the module-level invalidation function."""
q = base.message_queue()
b = Book.objects.get(id=1)
invalidate(Book)
b = Book.objects.get(id=1)
first, second = q.get_nowait(), q.get_nowait()
self.assertFalse(first)
self.assertFalse(second)
g = Genre.objects.get(id=1)
p = Publisher.objects.get(id=1)
invalidate('testapp_genre', Publisher)
g = Genre.objects.get(id=1)
p = Publisher.objects.get(id=1)
fg,fp,sg,sp = [q.get() for i in range(4)]
self.assertFalse(fg)
self.assertFalse(fp)
self.assertFalse(sg)
self.assertFalse(sp)
def test_invalidate(self):
"""Test for the module-level invalidation function."""
q = base.message_queue()
b = Book.objects.get(id=1)
invalidate(Book)
b = Book.objects.get(id=1)
first, second = q.get_nowait(), q.get_nowait()
self.assertFalse(first)
self.assertFalse(second)
g = Genre.objects.get(id=1)
p = Publisher.objects.get(id=1)
invalidate('testapp_genre', Publisher)
g = Genre.objects.get(id=1)
p = Publisher.objects.get(id=1)
fg, fp, sg, sp = [q.get() for i in range(4)]
self.assertFalse(fg)
self.assertFalse(fp)
self.assertFalse(sg)
self.assertFalse(sp)
def _move_node(self, request):
cut_item = self.model._tree_manager.get(pk=request.POST.get('cut_item'))
pasted_on = self.model._tree_manager.get(pk=request.POST.get('pasted_on'))
position = request.POST.get('position')
if position in ('last-child', 'left'):
if "johnny" in django_settings.INSTALLED_APPS:
from johnny.cache import invalidate
invalidate(self.model)
try:
self.model._tree_manager.move_node(cut_item, pasted_on, position)
except InvalidMove, e:
self.message_user(request, unicode(e))
return HttpResponse('FAIL')
# Ensure that model save has been run
cut_item = self.model._tree_manager.get(pk=cut_item.pk)
cut_item.save()
self.message_user(request, ugettext('%s has been moved to a new position.') %
cut_item)
return HttpResponse('OK')
def clean(self):
if self._errors:
return
invalidate('auth_user')
user = authenticate(username=self.cleaned_data["username"], password=self.cleaned_data["password"])
if user:
try:
profile = user.get_profile()
except Profile.DoesNotExist:
profile = Profile.objects.create_profile(user=user)
if user.is_active and profile.status == True and profile.status_detail.lower() == 'active':
self.user = user
else:
raise forms.ValidationError(_("This account is currently inactive."))
else:
try:
self.user_exists = User.objects.get(username=self.cleaned_data["username"])
raise forms.ValidationError(_("The username and/or password you specified are not correct."))
except User.DoesNotExist:
raise forms.ValidationError(_("The username and/or password you specified are not correct."))
return self.cleaned_data
def handle(self, *args, **options):
from tendenci.apps.reports.models import Run
try:
run_id = args[0]
except Exception:
raise CommandError('You need to pass a report run as an argument.')
try:
run = Run.objects.get(pk=run_id)
except (Run.DoesNotExist, Run.MultipleObjectsFound):
raise CommandError(
'The Run %s could not be found in the database.' % run_id)
if run.status == "unstarted":
run.status = "running"
run.start_dt = datetime.now()
run.save()
invalidate('reports_run')
print "running report"
report_output = "Report Output Here"
run.output = report_output
if run.report.type == "invoices":
run.output = self.report_output_invoices(run=run)
print "report complete"
if not run.status == "error":
run.status = "complete"
run.complete_dt = datetime.now()
run.save()
invalidate('reports_run')
else:
print "Report is already running"
def handle(self, *args, **options):
from tendenci.apps.reports.models import Run
try:
run_id = args[0]
except Exception:
raise CommandError('You need to pass a report run as an argument.')
try:
run = Run.objects.get(pk=run_id)
except (Run.DoesNotExist, Run.MultipleObjectsFound):
raise CommandError('The Run %s could not be found in the database.' % run_id)
if run.status == "unstarted":
run.status = "running"
run.start_dt = datetime.now()
run.save()
invalidate('reports_run')
print "running report"
report_output = "Report Output Here"
run.output = report_output
if run.report.type == "invoices":
run.output = self.report_output_invoices(run=run)
print "report complete"
if not run.status == "error":
run.status = "complete"
run.complete_dt = datetime.now()
run.save()
invalidate('reports_run')
else:
print "Report is already running"
def handle(self, *args, **kwargs):
from tendenci.apps.dashboard.models import DashboardStat, DashboardStatType
print "Creating dashboard statistics for upcoming events"
stat_type,created = DashboardStatType.objects.get_or_create(name="events_upcoming")
if created:
stat_type.description = "Upcoming 5 Events"
stat_type.save()
events = DashboardStat(key=stat_type)
events.value = json.dumps(self.get_events(5), use_decimal=True)
events.save()
print "Creating dashboard statistics for form submissions"
stat_type,created = DashboardStatType.objects.get_or_create(name="forms_30_submissions")
if created:
stat_type.description = "Top 5 Forms"
stat_type.save()
forms = DashboardStat(key=stat_type)
forms.value = json.dumps(self.get_forms(5, 30))
forms.save()
print "Creating dashboard statistics for pages traffic", datetime.now()
stat_type,created = DashboardStatType.objects.get_or_create(name="pages_30_traffic")
if created:
stat_type.description = "Top 5 Pages"
stat_type.save()
pages_traffic = DashboardStat(key=stat_type)
pages_traffic.value = json.dumps(self.get_pages_traffic(5, 30))
pages_traffic.save()
print "Creating dashboard statistics for events traffic", datetime.now()
stat_type,created = DashboardStatType.objects.get_or_create(name="events_30_traffic")
if created:
stat_type.description = "Top 5 Events"
stat_type.save()
events_traffic = DashboardStat(key=stat_type)
events_traffic.value = json.dumps(self.get_events_traffic(5, 30))
events_traffic.save()
print "Creating dashboard statistics for memberships", datetime.now()
stat_type,created = DashboardStatType.objects.get_or_create(name="memberships_30_count")
if created:
stat_type.description = "Members"
stat_type.save()
members = DashboardStat(key=stat_type)
members.value = json.dumps(self.get_membership_count(30))
members.save()
print "Creating dashboard statistics for new memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="memberships_30_new")
if created:
stat_type.description = "Memberships in the Past 30 Days"
stat_type.save()
mem_new = DashboardStat(key=stat_type)
mem_new.value = json.dumps(self.get_new_memberships(5, 30))
mem_new.save()
print "Creating dashboard statistics for renewed memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="memberships_30_renew")
if created:
stat_type.description = "Renewed Memberships in the Past 30 days"
stat_type.save()
mem_renew = DashboardStat(key=stat_type)
mem_renew.value = json.dumps(self.get_renew_memberships(5, 30))
mem_renew.save()
print "Creating dashboard statistics for expired memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="memberships_30_expired")
if created:
stat_type.description = "Expired memberships in the Past 30 days"
stat_type.save()
mem_expired = DashboardStat(key=stat_type)
mem_expired.value = json.dumps(self.get_expired_memberships(5, 30))
mem_expired.save()
print "Creating dashboard statistics for expiring memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="memberships_30_expiring")
if created:
stat_type.description = "Upcoming Expiring Memberships"
stat_type.save()
mem_expiring = DashboardStat(key=stat_type)
mem_expiring.value = json.dumps(self.get_expiring_memberships(5, 30))
mem_expiring.save()
print "Creating dashboard statistics for new corporate memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="corp_memberships_30_new")
if created:
stat_type.description = "Corporate Memberships in the Past 30 Days"
stat_type.save()
corp_new = DashboardStat(key=stat_type)
corp_new.value = json.dumps(self.get_new_corp_memberships(5, 30))
corp_new.save()
print "Creating dashboard statistics for renewed corporate memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="corp_memberships_30_renew")
if created:
stat_type.description = "Renewed Corporate Memberships in the Past 30 Days"
stat_type.save()
corp_renew = DashboardStat(key=stat_type)
corp_renew.value = json.dumps(self.get_renew_corp_memberships(5, 30))
corp_renew.save()
print "Creating dashboard statistics for expired corporate memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="corp_memberships_30_expired")
if created:
stat_type.description = "Expired Corporate Memberships in the Past 30 Days"
stat_type.save()
corp_expired = DashboardStat(key=stat_type)
corp_expired.value = json.dumps(self.get_expired_corp_memberships(5, 30))
corp_expired.save()
print "Creating dashboard statistics for expiring corporate memberships"
stat_type,created = DashboardStatType.objects.get_or_create(name="corp_memberships_30_expiring")
if created:
stat_type.description = "Upcoming Expiring Corporate Memberships"
stat_type.save()
corp_expiring = DashboardStat(key=stat_type)
corp_expiring.value = json.dumps(self.get_expiring_corp_memberships(5, 30))
corp_expiring.save()
print "Creating dashboard statistics for top corporate members"
stat_type,created = DashboardStatType.objects.get_or_create(name="corp_members_top")
if created:
stat_type.description = "Top Corporate Memberships"
stat_type.save()
corp_members = DashboardStat(key=stat_type)
corp_members.value = json.dumps(self.get_top_corp_members(5))
corp_members.save()
invalidate('dashboard_dashboardstat')
def end_with_error(self, run):
run.status = "error"
run.complete_dt = datetime.now()
run.save()
invalidate('reports_run')
def invalidate(model):
try: # try invalidating cache for model (have no idea if this is right)
from johnny.cache import invalidate
invalidate(model)
except:
pass
def end_with_error(self, run):
run.status = "error"
run.complete_dt = datetime.now()
run.save()
invalidate('reports_run')
def handle(self, *app_labels, **options):
from django.core.cache import cache
from django.db.models import get_app, get_apps, get_models, get_model
from django.utils.datastructures import SortedDict
from johnny.cache import invalidate
from johnny.middleware import QueryCacheMiddleware
log = logging.getLogger('clear_johnny_cache')
# enable queryset cache
q = QueryCacheMiddleware()
all_models = options.get('all_models')
exclude = options.get('exclude')
excluded_apps = set(get_app(app_label) for app_label in exclude)
app_list = None
if all_models:
if len(app_labels):
# FIXME: warn user that specifying apps on the command line when
# using -all-models options has no impact
pass
app_list = SortedDict((app, None) for app in get_apps() if app not in excluded_apps)
elif not len(app_labels) == 0:
app_list = SortedDict()
for label in app_labels:
try:
app_label, model_label = label.split('.')
try:
app = get_app(app_label)
except ImproperlyConfigured:
raise CommandError("Unknown application: %s" % app_label)
model = get_model(app_label, model_label)
if model is None:
raise CommandError("Unknown model: %s.%s" % (app_label, model_label))
if app in app_list.keys():
if app_list[app] and model not in app_list[app]:
app_list[app].append(model)
else:
app_list[app] = [model]
except ValueError:
# This is just an app - no model qualifier
app_label = label
try:
app = get_app(app_label)
except ImproperlyConfigured:
raise CommandError("Unknown application: %s" % app_label)
app_list[app] = None
if app_list:
# Generate a list of models to be invalidated, and call the Johnny
# Cache invalidate command.
full_model_list = []
for app, model_list in app_list.items():
if model_list is None:
model_list = get_models(app)
if model_list:
full_model_list.extend(model_list)
log.info('Trying to clear cache for %d app(s), %d model(s) to invalidate' % (len(app_list), len(full_model_list)))
for model in full_model_list:
log.info('Invalidating cache for %s' % (model._meta.module_name))
invalidate(model)
log.info('Done invalidating')
else:
log.info('No model to invalidate')
def import_data(file, user):
matched = read_columns(file)
table = load_file(file)
if jc_backend:
jc_backend.unpatch()
for col in matched:
col['item'] = file.relationships.get(pk=col['rel_id']).right
col['item_id'] = get_object_id(col['item'])
file_globals = {
'event_key': {},
'report_meta': {
'user': user,
'status': DEFAULT_STATUS,
},
'param_vals': {}
}
for field_name in EVENT_KEY:
info = Event._meta.get_field_by_name(field_name)
field = info[0]
if field.null:
file_globals['event_key'][field_name] = None
def save_value(col, val, obj):
item = col['item']
if isinstance(item, Parameter):
if col['item_id'] in obj['param_vals']:
obj['param_vals'][col['item_id']] = "%s %s" % (
obj['param_vals'][col['item_id']],
val
)
else:
obj['param_vals'][col['item_id']] = val
elif isinstance(item, MetaColumn):
if val is None or val == '':
return
if item.type == 'event':
if '.' in item.name:
name, part = item.name.split('.')
else:
name, part = item.name, None
fld = Event._meta.get_field_by_name(
name
)[0].get_internal_type()
if (fld in DATE_FIELDS and isinstance(val, basestring)):
from dateutil.parser import parse
val = parse(val)
if fld == 'DateField':
val = val.date()
# Handle date & time being separate columns
if obj['event_key'].get(name) is not None:
other_val = obj['event_key'][name]
if not part:
raise Exception(
'Expected multi-column date and time for %s' % name
)
if part not in ('date', 'time'):
raise Exception(
'Unexpected field name: %s.%s!' % (name, part)
)
if part == 'date':
date, time = val, other_val
else:
date, time = other_val, val
if not isinstance(date, datetime.date):
raise Exception("Expected date but got %s!" % date)
if not isinstance(time, datetime.time):
if (isinstance(time, float)
and time >= 100 and time <= 2400):
time = str(time)
if len(time) == 3:
time = datetime.time(
int(time[0]),
int(time[1:2])
)
else:
time = datetime.time(
int(time[0:1]),
int(time[2:3])
)
else:
raise Exception("Expected time but got %s!" % time)
val = datetime.datetime.combine(date, time)
obj['event_key'][name] = val
elif item.type == 'report':
obj['report_meta'][item.name] = val
for col in matched:
if 'value' in col:
save_value(col, col['value'], file_globals)
def add_record(row):
record = {
key: file_globals[key].copy()
for key in file_globals
}
for col in matched:
if 'colnum' in col:
save_value(col, row[col['colnum']], record)
if len(record['event_key'].keys()) < len(EVENT_KEY):
raise Exception('Incomplete Record')
return Report.objects.create_report(
EventKey(**record['event_key']),
record['param_vals'],
**record['report_meta']
)
rows = len(table)
errors = []
skipped = []
def rownum(i):
return i + table.start_row + 1
for i, row in enumerate(table):
current_task.update_state(state='PROGRESS', meta={
'current': i + 1,
'total': rows,
'skipped': skipped
})
skipreason = None
try:
report = add_record(row)
except Exception as e:
skipreason = repr(e)
skipped.append({'row': rownum(i), 'reason': skipreason})
report, is_new = SkippedRecord.objects.get_or_create(
reason=skipreason
)
rel = file.create_relationship(
report,
'Contains Row',
'Row In'
)
Range.objects.create(
relationship=rel,
type='row',
start_row=i + table.start_row,
start_column=0,
end_row=i + table.start_row,
end_column=len(row) - 1
)
status = {
'current': i + 1,
'total': rows,
'skipped': skipped
}
if jc_backend:
jc_backend.patch()
if rows and rows > len(skipped):
from johnny.cache import invalidate
invalidate(*[
cls._meta.db_table for cls in
(File, Site, Event, Report, Parameter, Result, Relationship)
])
import_complete.send(sender=import_data, file=file, status=status)
return status
def get_object(self, **kwargs):
invalidate('reports_run')
obj = get_object_or_404(Run, pk=self.kwargs['pk'], report_id=self.kwargs['report_id'])
return obj
def get_object(self, **kwargs):
invalidate('reports_run')
obj = get_object_or_404(Run, pk=self.kwargs['pk'], report_id=self.kwargs['report_id'])
if obj.status == "unstarted":
subprocess.Popen(["python", "manage.py", "process_report_run", str(obj.pk)])
return obj
def merge_process(request, sid):
if not request.user.profile.is_superuser:
raise Http403
sid = str(sid)
master = (request.session[sid]).get('master', '')
users = (request.session[sid]).get('users', '')
if master and users:
# get description for event log before users get deleted
description = 'Master user: %s, merged user(s): %s.' % (
'%s %s (%s)(id=%d)' % (master.user.first_name,
master.user.last_name,
master.user.username,
master.user.id),
', '.join(['%s %s (%s)(id=%d)' % (
profile.user.first_name,
profile.user.last_name,
profile.user.username,
profile.user.id
) for profile in users if profile != master]))
related = master.user._meta.get_all_related_objects()
field_names = master._meta.get_all_field_names()
valnames = dict()
for r in related:
if not r.model is Profile:
valnames.setdefault(r.model, []).append(r.field)
for profile in users:
if profile != master:
for field in field_names:
if getattr(master, field) == '':
setattr(master, field, getattr(profile, field))
for model, fields in valnames.iteritems():
for field in fields:
if not isinstance(field, models.OneToOneField):
objs = model.objects.filter(**{field.name: profile.user})
# handle unique_together fields. for example, GroupMembership
# unique_together = ('group', 'member',)
[unique_together] = model._meta.unique_together[:1] or [None]
if unique_together and field.name in unique_together:
for obj in objs:
field_values = [getattr(obj, field_name) for field_name in unique_together]
field_dict = dict(zip(unique_together, field_values))
# switch to master user
field_dict[field.name] = master.user
# check if the master record exists
if model.objects.filter(**field_dict).exists():
obj.delete()
else:
setattr(obj, field.name, master.user)
obj.save()
else:
if objs.exists():
objs.update(**{field.name: master.user})
else: # OneToOne
[obj] = model.objects.filter(**{field.name: profile.user})[:1] or [None]
if obj:
[master_obj] = model.objects.filter(**{field.name: master.user})[:1] or [None]
if not master_obj:
setattr(obj, field.name, master.user)
obj.save()
else:
obj_fields = master_obj._meta.get_all_field_names()
updated = False
for fld in obj_fields:
master_val = getattr(master_obj, fld)
if master_val == '' or master_val is None:
val = getattr(obj, fld)
if val != '' and not val is None:
setattr(master_obj, fld, val)
updated = True
if updated:
master_obj.save()
# delete obj
obj.delete()
master.save()
profile.user.delete()
profile.delete()
# log an event
EventLog.objects.log(description=description[:120])
invalidate('profiles_profile')
messages.add_message(request, messages.SUCCESS, 'Successfully merged users. %s' % description)
request.session['password_promt'] = False
return redirect("profile.search")
def handle(self, *args, **kwargs):
from tendenci.apps.dashboard.models import DashboardStat, DashboardStatType
print "Creating dashboard statistics for upcoming events"
stat_type, created = DashboardStatType.objects.get_or_create(
name="events_upcoming")
if created:
stat_type.description = "Upcoming 5 Events"
stat_type.save()
events = DashboardStat(key=stat_type)
events.value = json.dumps(self.get_events(5), use_decimal=True)
events.save()
print "Creating dashboard statistics for form submissions"
stat_type, created = DashboardStatType.objects.get_or_create(
name="forms_30_submissions")
if created:
stat_type.description = "Top 5 Forms"
stat_type.save()
forms = DashboardStat(key=stat_type)
forms.value = json.dumps(self.get_forms(5, 30))
forms.save()
print "Creating dashboard statistics for pages traffic", datetime.now()
stat_type, created = DashboardStatType.objects.get_or_create(
name="pages_30_traffic")
if created:
stat_type.description = "Top 5 Pages"
stat_type.save()
pages_traffic = DashboardStat(key=stat_type)
pages_traffic.value = json.dumps(self.get_pages_traffic(5, 30))
pages_traffic.save()
print "Creating dashboard statistics for events traffic", datetime.now(
)
stat_type, created = DashboardStatType.objects.get_or_create(
name="events_30_traffic")
if created:
stat_type.description = "Top 5 Events"
stat_type.save()
events_traffic = DashboardStat(key=stat_type)
events_traffic.value = json.dumps(self.get_events_traffic(5, 30))
events_traffic.save()
print "Creating dashboard statistics for memberships", datetime.now()
stat_type, created = DashboardStatType.objects.get_or_create(
name="memberships_30_count")
if created:
stat_type.description = "Members"
stat_type.save()
members = DashboardStat(key=stat_type)
members.value = json.dumps(self.get_membership_count(30))
members.save()
print "Creating dashboard statistics for new memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="memberships_30_new")
if created:
stat_type.description = "Memberships in the Past 30 Days"
stat_type.save()
mem_new = DashboardStat(key=stat_type)
mem_new.value = json.dumps(self.get_new_memberships(5, 30))
mem_new.save()
print "Creating dashboard statistics for renewed memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="memberships_30_renew")
if created:
stat_type.description = "Renewed Memberships in the Past 30 days"
stat_type.save()
mem_renew = DashboardStat(key=stat_type)
mem_renew.value = json.dumps(self.get_renew_memberships(5, 30))
mem_renew.save()
print "Creating dashboard statistics for expired memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="memberships_30_expired")
if created:
stat_type.description = "Expired memberships in the Past 30 days"
stat_type.save()
mem_expired = DashboardStat(key=stat_type)
mem_expired.value = json.dumps(self.get_expired_memberships(5, 30))
mem_expired.save()
print "Creating dashboard statistics for expiring memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="memberships_30_expiring")
if created:
stat_type.description = "Upcoming Expiring Memberships"
stat_type.save()
mem_expiring = DashboardStat(key=stat_type)
mem_expiring.value = json.dumps(self.get_expiring_memberships(5, 30))
mem_expiring.save()
print "Creating dashboard statistics for new corporate memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="corp_memberships_30_new")
if created:
stat_type.description = "Corporate Memberships in the Past 30 Days"
stat_type.save()
corp_new = DashboardStat(key=stat_type)
corp_new.value = json.dumps(self.get_new_corp_memberships(5, 30))
corp_new.save()
print "Creating dashboard statistics for renewed corporate memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="corp_memberships_30_renew")
if created:
stat_type.description = "Renewed Corporate Memberships in the Past 30 Days"
stat_type.save()
corp_renew = DashboardStat(key=stat_type)
corp_renew.value = json.dumps(self.get_renew_corp_memberships(5, 30))
corp_renew.save()
print "Creating dashboard statistics for expired corporate memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="corp_memberships_30_expired")
if created:
stat_type.description = "Expired Corporate Memberships in the Past 30 Days"
stat_type.save()
corp_expired = DashboardStat(key=stat_type)
corp_expired.value = json.dumps(
self.get_expired_corp_memberships(5, 30))
corp_expired.save()
print "Creating dashboard statistics for expiring corporate memberships"
stat_type, created = DashboardStatType.objects.get_or_create(
name="corp_memberships_30_expiring")
if created:
stat_type.description = "Upcoming Expiring Corporate Memberships"
stat_type.save()
corp_expiring = DashboardStat(key=stat_type)
corp_expiring.value = json.dumps(
self.get_expiring_corp_memberships(5, 30))
corp_expiring.save()
print "Creating dashboard statistics for top corporate members"
stat_type, created = DashboardStatType.objects.get_or_create(
name="corp_members_top")
if created:
stat_type.description = "Top Corporate Memberships"
stat_type.save()
corp_members = DashboardStat(key=stat_type)
corp_members.value = json.dumps(self.get_top_corp_members(5))
corp_members.save()
invalidate('dashboard_dashboardstat')
def delete_rule_components_for_a_tagset(sender, instance, created=None, *args, **kwargs):
from rules.models import LeftSide
LeftSide.objects_by_account(instance.account).using('default').filter(display_name="have a %s tag that" % (instance.name)).delete()
johnny_cache.invalidate(LeftSide)
def populate_rule_components_for_an_account(account):
try:
from accounts.models import Account
from rules.models import LeftSide, Operator, RightSideType
from volunteers import VOLUNTEER_STATII
from donors import DONATION_TYPES
account = Account.objects.using("default").get(pk=account.pk)
"""This function performs several actions, and is idempotent.
In order, it:
- Sets up built-in rule options (like volunteer status)
- Sets up data-driven rule options (like custom tag sets)
- Cleans up unused rule options
"""
# print "populating for %s" % account
request = Dummy()
request.account = account
# RightSideTypes
all_right_side_types = []
right_type_text = RightSideType.raw_objects.using('default').get_or_create(account=account, name="text")[0]
right_type_date = RightSideType.raw_objects.using('default').get_or_create(account=account, name="date")[0]
right_type_number = RightSideType.raw_objects.using('default').get_or_create(account=account, name="number")[0]
right_type_choices = RightSideType.raw_objects.using('default').get_or_create(account=account,name="choices")[0]
all_right_side_types = [right_type_text, right_type_date, right_type_number, right_type_choices]
# Operators
all_operators = []
operator_contains = Operator.raw_objects.using('default').get_or_create(account=account, display_name="contains" , query_string_partial="__icontains=" , use_filter=True)[0]
operator_contains.order = 10
operator_contains.save()
operator_does_not_contain = Operator.raw_objects.using('default').get_or_create(account=account, display_name="does not contain" , query_string_partial="__icontains=" , use_filter=False)[0]
operator_does_not_contain.order = 20
operator_does_not_contain.save()
operator_is = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is" , query_string_partial="=" , use_filter=True)[0]
operator_is.order = 30
operator_is.save()
operator_is_not = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is not" , query_string_partial="=" , use_filter=False)[0]
operator_is_not.order = 40
operator_is_not.save()
operator_is_exactly = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is exactly" , query_string_partial="__iexact=" , use_filter=True)[0]
operator_is_exactly.order = 50
operator_is_exactly.save()
operator_is_not_exactly = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is not exactly" , query_string_partial="__iexact=" , use_filter=False)[0]
operator_is_not_exactly.order = 60
operator_is_not_exactly.save()
operator_is_on = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is on" , query_string_partial="=" , use_filter=True)[0]
operator_is_on.order = 70
operator_is_on.save()
operator_is_before = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is before" , query_string_partial="__lt=" , use_filter=True)[0]
operator_is_before.order = 80
operator_is_before.save()
operator_is_after = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is after" , query_string_partial="__gt=" , use_filter=True)[0]
operator_is_after.order = 90
operator_is_after.save()
operator_is_equal = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is equal to" , query_string_partial="=" , use_filter=True)[0]
operator_is_equal.order = 100
operator_is_equal.save()
operator_is_less_than = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is less than" , query_string_partial="__lt=" , use_filter=True)[0]
operator_is_less_than.order = 110
operator_is_less_than.save()
operator_is_more_than = Operator.raw_objects.using('default').get_or_create(account=account, display_name="is more than" , query_string_partial="__gt=" , use_filter=True)[0]
operator_is_more_than.order = 120
operator_is_more_than.save()
all_operators = [ operator_is_exactly, operator_is_not_exactly, operator_contains, operator_does_not_contain,
operator_is, operator_is_not,
operator_is_on, operator_is_before, operator_is_after,
operator_is_equal, operator_is_less_than, operator_is_more_than,
]
# Helper methods
all_left_sides = []
def _add_text_operators(ls):
ls.allowed_operators.clear()
ls.allowed_operators.add(operator_is_exactly)
ls.allowed_operators.add(operator_is_not_exactly)
ls.allowed_operators.add(operator_contains)
ls.allowed_operators.add(operator_does_not_contain)
ls.save()
def _add_right_type_text(ls):
ls.allowed_right_side_types.clear()
ls.allowed_right_side_types.add(right_type_text)
ls.save()
def _add_operators_and_right_side_text(ls):
_add_text_operators(ls)
_add_right_type_text(ls)
def _add_date_operators(ls):
ls.allowed_operators.clear()
ls.allowed_operators.add(operator_is_on)
ls.allowed_operators.add(operator_is_before)
ls.allowed_operators.add(operator_is_after)
ls.save()
def _add_right_type_date(ls):
ls.allowed_right_side_types.clear()
ls.allowed_right_side_types.add(right_type_date)
ls.save()
def _add_operators_and_right_side_date(ls):
_add_date_operators(ls)
_add_right_type_date(ls)
def _add_number_operators(ls):
ls.allowed_operators.clear()
ls.allowed_operators.add(operator_is_equal)
ls.allowed_operators.add(operator_is_less_than)
ls.allowed_operators.add(operator_is_more_than)
ls.save()
def _add_right_type_number(ls):
ls.allowed_right_side_types.clear()
ls.allowed_right_side_types.add(right_type_number)
ls.save()
def _add_operators_and_right_side_number(ls):
_add_number_operators(ls)
_add_right_type_number(ls)
def _add_tag_operators(ls):
ls.allowed_operators.clear()
ls.allowed_operators.add(operator_is_exactly)
ls.allowed_operators.add(operator_contains)
ls.save()
def _add_operators_and_right_side_tag(ls):
_add_tag_operators(ls)
_add_right_type_text(ls)
def _add_choices_operators(ls):
ls.allowed_operators.clear()
ls.allowed_operators.add(operator_is)
ls.allowed_operators.add(operator_is_not)
ls.save()
def _add_right_type_choices(ls):
ls.allowed_right_side_types.clear()
ls.allowed_right_side_types.add(right_type_choices)
ls.save()
def _add_operators_and_right_side_choices(ls):
_add_choices_operators(ls)
_add_right_type_choices(ls)
def _add_to_all_left_sides(ls):
all_left_sides.append(ls)
def left_side_for_text(**kwargs):
if not "display_name" in kwargs or not "query_string_partial" in kwargs:
raise Exception, "display_name and query_string_partial not passed!"
ls = LeftSide.raw_objects.using('default').get_or_create(**kwargs)[0]
_add_operators_and_right_side_text(ls)
_add_to_all_left_sides(ls)
return ls
def left_side_for_date(**kwargs):
if not "display_name" in kwargs or not "query_string_partial" in kwargs:
raise Exception, "display_name and query_string_partial not passed!"
ls = LeftSide.raw_objects.using('default').get_or_create(**kwargs)[0]
_add_operators_and_right_side_date(ls)
_add_to_all_left_sides(ls)
return ls
def left_side_for_number(**kwargs):
if not "display_name" in kwargs or not "query_string_partial" in kwargs:
raise Exception, "display_name and query_string_partial not passed!"
ls = LeftSide.raw_objects.using('default').get_or_create(**kwargs)[0]
_add_operators_and_right_side_number(ls)
_add_to_all_left_sides(ls)
return ls
def left_side_for_tag(**kwargs):
if not "display_name" in kwargs or not "query_string_partial" in kwargs:
raise Exception, "display_name and query_string_partial not passed!"
ls = LeftSide.raw_objects.using('default').get_or_create(**kwargs)[0]
_add_operators_and_right_side_tag(ls)
_add_to_all_left_sides(ls)
return ls
def left_side_for_choices(**kwargs):
if not "display_name" in kwargs or not "query_string_partial" in kwargs:
raise Exception, "display_name and query_string_partial not passed!"
choices = kwargs["choices"]
del kwargs["choices"]
ls = LeftSide.raw_objects.using('default').get_or_create(**kwargs)[0]
if not ls.choices == choices:
ls.choices = choices
ls.save()
_add_operators_and_right_side_choices(ls)
_add_to_all_left_sides(ls)
return ls
# Left sides - built-ins
ls = left_side_for_tag (account=account, display_name="have any tag that" ,query_string_partial="taggeditem__tag__name" )
ls.order=10
ls.save()
ls = left_side_for_choices(account=account, display_name="volunteer status" ,query_string_partial="volunteer__status" , choices=VOLUNTEER_STATII)
ls.order=100
ls.save()
ls = left_side_for_date(account=account, display_name="last donation" ,query_string_partial="donor__donation__date" )
ls.order=110
ls.save()
# left_side_for_number(account=account, display_name="total donations in the last 12 months" ,query_string_partial="donor__twelvemonth_total" )
# ls.order=120
# ls.save()
ls = left_side_for_date(account=account, display_name="last volunteer shift" ,query_string_partial="volunteer__completedshift__date" )
ls.order=130
ls.save()
# left_side_for_number(account=account, display_name="total volunteer hours in the last 12 months" ,query_string_partial="volunteer__twelvemonth_total" )
# ls.order=140
# ls.save()
ls = left_side_for_date (account=account, display_name="last conversation" ,query_string_partial="conversation__date" )
ls.order=150
ls.save()
ls = left_side_for_date (account=account, display_name="birthday" ,query_string_partial="actual_birthday" )
ls.order=170
ls.save()
ls = left_side_for_number (account=account, display_name="age" ,query_string_partial="age" )
ls.order=190
ls.save()
ls = left_side_for_choices (account=account, display_name="have a donation that" ,query_string_partial="donor__donation__type", choices=DONATION_TYPES )
ls.order=210
ls.save()
# Left sides - generateds
from generic_tags.models import TagSet
i = 0
for ts in TagSet.objects_by_account(account).using('default').all():
i = i+1
ls = left_side_for_tag(account=account,
display_name="have a %s tag that" % (ts.name),
query_string_partial="taggeditem__tag__in=Tag.objects_by_account(self.account).filter(tagset__name='%s',name" % (ts.name),
add_closing_paren=True
)
ls.order=20+i
ls.save()
# Cleanup
for rs in RightSideType.objects_by_account(account).using('default').all():
if rs not in all_right_side_types:
rs.delete()
for o in Operator.objects_by_account(account).using('default').all():
if o not in all_operators:
o.delete()
for ls in LeftSide.objects_by_account(account).using('default').all():
if ls not in all_left_sides:
ls.delete()
johnny_cache.invalidate(RightSideType)
johnny_cache.invalidate(Operator)
johnny_cache.invalidate(LeftSide)
except:
from django.core.mail import mail_admins
from qi_toolkit.helpers import exception_string
mail_admins("Exception generating group rules", exception_string(), fail_silently=True)
def handle(self, *app_labels, **options):
from django.core.cache import cache
from django.db.models import get_app, get_apps, get_models, get_model
from django.utils.datastructures import SortedDict
from johnny.cache import invalidate
from johnny.middleware import QueryCacheMiddleware
log = logging.getLogger('clear_johnny_cache')
# enable queryset cache
q = QueryCacheMiddleware()
all_models = options.get('all_models')
exclude = options.get('exclude')
excluded_apps = set(get_app(app_label) for app_label in exclude)
app_list = None
if all_models:
if len(app_labels):
# FIXME: warn user that specifying apps on the command line when
# using -all-models options has no impact
pass
app_list = SortedDict(
(app, None) for app in get_apps() if app not in excluded_apps)
elif not len(app_labels) == 0:
app_list = SortedDict()
for label in app_labels:
try:
app_label, model_label = label.split('.')
try:
app = get_app(app_label)
except ImproperlyConfigured:
raise CommandError("Unknown application: %s" %
app_label)
model = get_model(app_label, model_label)
if model is None:
raise CommandError("Unknown model: %s.%s" %
(app_label, model_label))
if app in app_list.keys():
if app_list[app] and model not in app_list[app]:
app_list[app].append(model)
else:
app_list[app] = [model]
except ValueError:
# This is just an app - no model qualifier
app_label = label
try:
app = get_app(app_label)
except ImproperlyConfigured:
raise CommandError("Unknown application: %s" %
app_label)
app_list[app] = None
if app_list:
# Generate a list of models to be invalidated, and call the Johnny
# Cache invalidate command.
full_model_list = []
for app, model_list in app_list.items():
if model_list is None:
model_list = get_models(app)
if model_list:
full_model_list.extend(model_list)
log.info(
'Trying to clear cache for %d app(s), %d model(s) to invalidate'
% (len(app_list), len(full_model_list)))
for model in full_model_list:
log.info('Invalidating cache for %s' %
(model._meta.module_name))
invalidate(model)
log.info('Done invalidating')
else:
log.info('No model to invalidate')
