def create_groups(): member = Group() member.name = settings.ATTENDANCE_MEMBER_GROUPNAME member.save() comite = Group() comite.name = settings.ATTENDANCE_COMMITTEE_GROUPNAME comite.save()
def create_class_in_school(school_group, grade_name, class_name):
gd_list = GroupDetail.objects.filter(upper_group=school_group, type='G', nickname=grade_name)
if len(gd_list) == 0:
g = Group()
g.name = grade_name
g.save()
g.groupdetail = GroupDetail()
g.groupdetail.group = g
g.groupdetail.type = 'G'
g.groupdetail.nickname = grade_name
g.groupdetail.upper_group = school_group
g.groupdetail.save()
g.name = str(g.id)
g.save()
grade_group = g
else:
grade_group = gd_list[0].group
gd_list = GroupDetail.objects.filter(upper_group=grade_group, type='C', nickname=class_name)
if len(gd_list) != 0:
return False
g = Group()
g.name = class_name
g.save()
g.groupdetail = GroupDetail()
g.groupdetail.group = g
g.groupdetail.type = 'C'
g.groupdetail.nickname = class_name
g.groupdetail.upper_group = grade_group
g.groupdetail.save()
g.name = str(g.id)
g.save()
return True
def install_groups():
exam = Group()
exam.name='ExamCell'
exam.save()
student = Group()
student.name='Student'
student.save()
dept = Group()
dept.name='Department'
dept.save()
def save_group(request):
perm = Permission.objects.all()
if request.method == 'POST':
form = GroupForm(request.POST)
if form.is_valid():
group = Group()
group.name = request.POST['name']
group.save()
group.permissions = request.POST.getlist('permission')
group.save()
return redirect('/permissions/group/')
else:
form = GroupForm()
return render(request, 'permissions/group/save.html', {
'form': form,
'permissions':perm,
})
def insert_roles(self):
for role in self.roles:
group = Group()
group.name = role.get('name')
group.save()
for permission in role.get('permissions'):
group.permissions.add(permission)
def groups():
'''sets up the groups'''
groupnames=[
{'n':'Principal',
'p':None},
{'n':'Bursar',
'p':None},
{'n':'Dean(Residence)',
'p':None},
{'n':'Dean(Academic Affairs)',
'p':None},
{'n':'Chaplain',
'p':None},
{'n':'Public Information Officer',
'p':None},
{'n':'Special Assignments',
'p':None},
{'n':'Administration',
'p':None},
{'n':'Staff Advisor',
'p':None},
{'n':'Faculty',
'p':None},
{'n':'Students',
'p':None}]
for i in groupnames:
a=Group()
a.name=i['n']
a.save()
def handle(self, *args, **options):
groups = settings.DEFAULT_GROUPS
for groupname in groups:
try:
g = Group.objects.get(name=groupname)
except Group.DoesNotExist:
g = Group()
g.name = groupname
g.save()
if g.name == "Default":
g.user_set = User.objects.all()
g.permissions = []
for permission in groups[groupname]:
try:
p = Permission.objects.get(codename=permission)
g.permissions.add(p)
except Permission.DoesNotExist:
if permission[0] == "*":
permissions = Permission.objects.filter(content_type__model=permission.split("_")[1])
for p in permissions:
g.permissions.add(p)
g.save()
def write_contacts():
global contacts
global allgroups
for group in allgroups :
grp = None
try:
grp = Group.objects.get(name=group)
except :
pass
if not grp :
grp = Group()
grp.name = group
grp.save()
for contact in contacts :
user = None
try:
user = User.objects.get(username=contact['email'])
except :
pass
if not user :
user = User()
user.username = contact['email']
user.email = contact['email']
user.is_active = False
user.last_name = contact['family_name']
user.first_name = contact['given_name']
user.save()
for grp in contact['groups']:
g = Group.objects.get(name=grp)
g.user_set.add(user)
user.save()
def get_system_config(request):
if request.method == 'POST':
form = SystemConfigForm(request.POST)
if form.is_valid():
config_set('system_url', form.cleaned_data['system_url'])
config_set('system_welcometext', form.cleaned_data['system_welcometext'])
if form.cleaned_data['system_enable_anonymous']:
config_set('system_enable_anonymous', True)
# check for Anonymous group and (re)create it as needed
try:
anonymous = Group.objects.get(name='Anonymous')
except Group.DoesNotExist:
default_perms = [u'can_see_agenda', u'can_see_projector', u'can_see_application']
anonymous = Group()
anonymous.name = 'Anonymous'
anonymous.save()
anonymous.permissions = Permission.objects.filter(codename__in=default_perms)
anonymous.save()
messages.success(request, _('Anonymous access enabled. Please modify the "Anonymous" group to fit your required permissions.'))
else:
# use '' - False will evaluate to uniced(False) => True..
config_set('system_enable_anonymous', '')
messages.success(request, _('System settings successfully saved.'))
else:
messages.error(request, _('Please check the form for errors.'))
else:
form = SystemConfigForm(initial={
'system_url': config_get('system_url'),
'system_welcometext': config_get('system_welcometext'),
'system_enable_anonymous': config_get('system_enable_anonymous'),
})
return {
'form': form,
}
def generate_groups(request):
groups = ['Doctor', 'Head Doctor', 'Nurse', 'Head Nurse', 'Sales', 'DB Admin']
for g in groups:
new = Group()
new.name = g
new.save()
return HttpResponse(':)')
def handle(self, *args, **options):
try:
importGroup = Group.objects.get(name__exact='Imported Users')
except ObjectDoesNotExist, e:
importGroup = Group()
importGroup.name = 'Imported Users'
importGroup.save()
def get_group(group_name):
try:
group = Group.objects.get(name=group_name)
except Group.DoesNotExist:
group = Group()
group.name = group_name
group.save()
return group
def create_proj_object_perm_groups(self, project_obj):
""" Creates permissions groups for a project object """
output = False
ent = Entity()
found = ent.dereference(project_obj.uuid)
if found:
view_group = Group()
view_group.name = str(ent.label[:60]) + ' [Can View]'
view_group.save()
project_obj.view_group_id = view_group.id
edit_group = Group()
edit_group.name = str(ent.label[:60]) + ' [Can Edit]'
edit_group.save()
project_obj.edit_group_id = edit_group.id
project_obj.save()
output = project_obj
return output
def make_group(name):
for k in Group.objects.filter(name=name):
print 'Deleting group "%s"' % k.name
k.delete()
group = Group()
group.name = name
group.save()
print 'Created group "%s"' % (name)
return group
def get_group_configs(phpbb_group):
try:
group = AuthGroup.objects.get(id=phpbb_group.group_id)
except:
group = AuthGroup()
group.id = phpbb_group.group_id
group.name = phpbb_group.group_name
group.save()
return group.group_configs.all()
def crear_admingroup(self):
try:
adminGroup = Group()
adminGroup.name = 'Administradores'
print "creando grupo %s" % adminGroup.name
adminGroup.save()
for permiso in Permission.objects.all():
adminGroup.permissions.add(permiso)
except Exception:
print "no fue posible crear el grupo de administradores"
def main():
django.setup()
# Create/load surveyor group
try:
surveyor = Group.objects.get(name="Surveyor")
except Group.DoesNotExist:
surveyor = Group()
surveyor.name = "Surveyor"
surveyor.save()
# Create/load manager group
try:
manager = Group.objects.get(name="Manager")
except Group.DoesNotExist:
manager = Group()
manager.name = "Manager"
manager.save()
# Create/load users
test_manager = create_user('testmanager', 'test', 'Test', 'Manager', manager)
test_surveyor = create_user('testsurveyor', 'test', 'Test', 'Surveyor', surveyor)
test_checklist = Checklist(
title='Test Checklist',
description='this is a test checklist',
file_number=123,
land_district='land district test',
latitude=1.23,
longitude=1.23,
status=Checklist.COMPLETED,
created_by=test_manager,
assigned_to=test_surveyor
)
# Add the groups
test_checklist.save()
test_checklistitemselection = create_checklistitemselection(1, test_checklist, test_manager)
test_checklistitemselection = create_checklistitemselection(1, test_checklist, test_manager)
def save_new_group(request):
if request.method == 'POST':
form = GroupForm(request.POST)
if form.is_valid():
group = Group()
group.name = form.cleaned_data['name']
group.save()
return HttpResponseRedirect('/webconf/aclsmanager/show_groups/')
def test_authorisation_expression(self):
normal_user = User.objects.create_user('normal', '*****@*****.**', 'password')
super_user = User.objects.create_superuser('super', '*****@*****.**', 'password')
contrib_group = Group()
contrib_group.name = GROUP_EDIT_EVENTS
contrib_group.save()
contributor_user = User.objects.create_user('contributor', '*****@*****.**', 'password')
contributor_user.groups.add(contrib_group)
contributor_user.save()
self.assertTrue(user_in_group_or_super(super_user))
self.assertTrue(user_in_group_or_super(contributor_user))
self.assertFalse(user_in_group_or_super(normal_user))
def register(self):
from ou_fyp.services.templates.InputForm import RegisterForm;
uf = RegisterForm(self.request.request.POST);
if uf.is_valid():
u = uf.save(commit=False);
u.set_password(u.password);
u.save();
g = Group();
g.name = u.username;
g.save();
u.groups.add(g);
u.save();
if not self.request.request.is_ajax():
return HttpResponseRedirect("/user/login");
def crear_appgroup_delete(self):
try:
appGroup = Group()
appGroup.name = 'Web_only_delete'
print "creando grupo %s" % appGroup.name
appGroup.save()
print "otorgando permisos a %s" % appGroup.name
for modelo in MODELOS:
contenido = ContentType.objects.get(app_label=APP_NAME, model=modelo)
accion = 'delete'
code = accion + "_" + modelo
permiso = Permission.objects.get(content_type=contenido, codename=code)
appGroup.permissions.add(permiso)
except Exception as e:
print "no fue posible crear el grupo de Web"
def new(request):
myGroups = request.user.groups.exclude(name='agents') #user is agent
errorMessage=""
agents = User.objects.filter(groups__name=AGENTS_GROUP)
if (request.user.groups.filter(name=AGENTS_GROUP).count()>0):
agents = User.objects.filter(id=request.user.id)
if (request.POST):
form = groupForm(request.POST)
form.fields['agent'] = forms.ModelChoiceField(required=True,queryset=agents,empty_label=None)
if form.is_valid():
otherGroups = Group.objects.filter(name=form.cleaned_data["name"]) #user is agent
if otherGroups.count()>0:
errorMessage=_("Group already exists")
else:
group = Group()
group.name=form.cleaned_data["name"]
group.save()
#add targgueted agent too
ag = form.cleaned_data["agent"]
ag.groups.add(group)
ag.save()
#add admin
amin = User.objects.get(username='******')
amin.groups.add(group)
amin.save()
return HttpResponseRedirect('/groups/') # Redirect after POST
else:
form = groupForm()
form.fields['agent'] = forms.ModelChoiceField(required=True,queryset=agents,empty_label=None)
return render_to_response('groups/new.html',
{
'agents':agents,
'myGroups':myGroups,
'form':form,
'section':SECTION_GROUPS,
'errorMsg':errorMessage,
},context_instance=RequestContext(request))
def import_group_permissions():
from django.contrib.auth.models import Group, Permission
with open_csv('groups_permissions') as csv_file:
data = csv.reader(csv_file)
print 'Importing groups...'
for row in data:
group = Group()
group.id = row[0]
group.name = row[1]
group.save()
for perm in row[2:]:
permission = Permission.objects.get(name=perm)
group.permissions.add(permission)
def setUp(self):
perfil = Profile()
perfil.pk = 10
tabajara = Organization()
tabajara.pk = 555
grupo = Group()
grupo.pk = 19
joao = User()
joao.username = "******"
perfil.user = joao
tabajara.name = "zueira"
grupo.name = "grupo1"
self.papel = Role()
self.papel.profile = perfil
self.papel.organization = tabajara
self.papel.group = grupo
def save_meta(metadata):
tok = metadata['token']
try:
pr = ProxyRequest.objects.get(token = tok)
except:
return False
try:
print "adding "+metadata['provider']
ow = Owner.objects.get(name=metadata['provider'])
except:
print "new "+metadata['provider']
try:
ow = Owner()
ow.name = metadata['provider']
g = Group()
g.name = metadata['provider']
g.save()
ow.group = g
ow.save()
except:
pass
p = Proxy()
p.request = pr
pr.owner = ow
pr.save()
p.manifest = metadata
p.mode_read = metadata['operations']['read'] if metadata['operations']['read'] != "none" else None
p.mode_write = metadata['operations']['write'] if metadata['operations']['write'] != "none" else None
p.mode_query = json.dumps(metadata['operations']['query']) if metadata['operations']['query'] != "none" else None
p.save()
for md in metadata['metadata']:
mm = Metadata()
mm.proxy = p
mm.meta = json.dumps(md)
mm.BB_south = md['area'][0]
mm.BB_east = md['area'][1]
mm.BB_north = md['area'][2]
mm.BB_west = md['area'][3]
mm.name = md['name']
mm.save()
rt = MetadataRefreshTime()
rt.metadata = p
rt.save()
return True
def _dec(request, *args, **kw_args):
if not name or not models_list or len(models_list) < 1:
raise AttributeError("Decorator requires both name and models list")
try:
group = Group.objects.get(name=name)
except Group.DoesNotExist:
group = Group()
group.name = name
# Save and re-load in-order to get the primary key.
# Otherwise you cant have many-to-many relationship.
group.save()
codename_list = [perm + "_" + model for model in models_list for perm in permission_list]
permissions = Permission.objects.filter(codename__in=codename_list)
group.permissions = permissions
group.save()
return view_func(request, *args, **kw_args)
def get_user_group(group_name):
"""
gets or create a user group
:param group_name:
:return:
"""
try:
group = Group.objects.get(name=group_name)
return group
except:
print("Group does not exist: " + group_name)
try:
group = Group()
group.name = group_name
group.save()
print("Group created: " + group_name)
return group
except:
print("Error creating group: " + group_name)
def Alta_tusr(request):
# form = Form_Tusr()
ctx={'mensaje': 'Ingrese datos de nuevo tipo de usuario'}
if request.POST:
t= Group()
g = request.POST.get('Tipo_de_Usuario')
t.name = g
# t.descr = form.cleaned_data['Descripcion']
t.save()
# form = Form_Tusr()
ctx={'mensaje':'Registro exitoso!'}
else:
ctx={'mensaje':'Error en los datos.'}
return render(request,'Usuarios/alta_tusr.html',ctx)
def add_group(request):
content_types = ContentType.objects.filter(app_label = "myapp")
permissions = Permission.objects.filter(content_type__in=content_types).order_by('content_type__id','-codename')
context = {}
if request.POST :
try:
group_name = request.POST['txtGroupName']
group = Group()
group.name = group_name
group.save()
for permission in permissions:
if request.POST.get('checkboxPer'+str(permission.id)):
group.permissions.add(permission)
else:
group.permissions.remove(permission)
return HttpResponseRedirect("/group/")
except Exception as ex:
context.update({'has_error':ex})
context.update({'permissions':permissions})
context.update(csrf(request))
return render_to_response("admin/group/add-group.html",context, RequestContext(request))
def edit_groupschedule(req):
from django.contrib.auth.models import Group
from owner.models import GroupSchedule
try:
groupschedule = GroupSchedule.objects.get(owner=req.user)
group = groupschedule.group
except GroupSchedule.DoesNotExist:
groupschedule = GroupSchedule(owner=req.user)
group = Group()
if req.method == 'POST':
posted = req.POST
group.name = posted['name']
group.save()
groupschedule.group = group
groupschedule.start_point = int(posted['start_point'])
groupschedule.save()
return redirect('/')
#try:
#groupschedule = GroupSchedule.objects.get(owner=req.user)
#group = groupschedule.group
#group.name = posted['name']
#group.save()
#except GroupSchedule.DoesNotExist:
#group = Group.objects.create(name=posted['name'])
#groupschedule = GroupSchedule(owner=req.user,group=group,start_point=int(posted['start_point']))
#groupschedule.start_point = int(posted['start_point'])
#groupschedule.save()
return render(req,'owner/edit_groupschedule.html',{
'group_name':group.name,
'start_point':groupschedule.start_point,
'select_choices':(1,5,10,15,20,25,),
})
def CreateGroups(unused_apps, unused_schema_editor):
group_obj = Group()
group_obj.name = "can release alerts"
group_obj.save()
def run_commands():
entrysets = [
{
'group': {
'id': 14,
'name': 'Équipe Ferrand',
'description': 'Grants access to sources added by Guilhem Ferrand.',
'type': 3
},
'dataset': {
'name': 'Ferrand Sources',
'description': 'Contains sources added by Guilhem Ferrand.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'AD Aveyron'
]
},
{
'group': {
'name': 'Équipe Saussus',
'description': 'Grants access to sources added by Lise Saussus.',
'type': 3
},
'dataset': {
'name': 'Saussus Sources',
'description': 'Contains sources added by Lise Saussus.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'ADN'
],
'members': [56]
},
{
'group': {
'id': 12,
'name': 'Squadra LOC-GLOB',
'description': 'Grants access to sources added by the LOC-GLOB team.',
'type': 3
},
'dataset': {
'id': '15ecfc2e-6043-4e85-bed1-5f6b2f26c62f',
'name': 'LOC-GLOB Sources',
'description': 'Contains sources added by the LOC-GLOB team.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'ACBormio', 'ASBg', 'ASCM', 'ASOM', 'ASSo', 'ASTo'
],
'members': [58, 57]
},
{
'group': {
'name': 'Squadra Seche',
'description': 'Grants access to sources added by Giuseppe Seche.',
'type': 3
},
'dataset': {
'name': 'Seche Sources',
'description': 'Contains sources added by Giuseppe Seche.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'AS Pisa', 'ASCa'
]
},
{
'group': {
'name': 'Équipe Laumonier',
'description': 'Grants access to sources added by Lucie Laumonier.',
'type': 3
},
'dataset': {
'name': 'Laumonier Sources',
'description': 'Contains sources added by Lucie Laumonier.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'AD Hérault'
]
},
{
'group': {
'name': 'Harvard Team',
'description': 'Grants access to sources added by the Harvard DALME team.',
'type': 3
},
'dataset': {
'name': 'Harvard Sources',
'description': 'Contains sources added by the Harvard DALME team.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'ACSG', 'ACU', 'AD Haute Garonne', 'ADBR', 'AMM', 'AN', 'AS Bologna', 'AS Messina', 'ASF', 'ASGe', 'ASL', 'BHSA', 'GStA'
],
'members': [1, 5, 35, 36, 37, 38, 52, 64]
},
{
'group': {
'name': 'Team Lester-Morreale',
'description': 'Grants access to sources added by Anne Lester and Laura Morreale.',
'type': 3
},
'dataset': {
'name': 'Lester-Morreale Sources',
'description': 'Contains sources added by Anne Lester and Laura Morreale.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'AD Somme'
],
'members': [35]
},
{
'group': {
'name': 'Equipo Belenguer',
'description': 'Grants access to sources added by Antonio Belenguer.',
'type': 3
},
'dataset': {
'id': '002edb8f-7fd2-433a-b5d6-df8def749cee',
'name': 'Belenguer Sources',
'description': 'Contains sources added by Antonio Belenguer.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'APPV', 'AR Mallorca', 'AR València'
]
},
{
'group': {
'id': 13,
'name': 'Hinds Team',
'description': 'Grants access to sources added by Sarah Hinds.',
'type': 3
},
'dataset': {
'id': '5ef056a0-b060-4b5e-9f66-5e05434d7352',
'name': 'Hinds Sources',
'description': 'Contains sources added by Sarah Hinds.',
'set_type': 3,
'endpoint': 'sources',
'permissions': 2
},
'archives': [
'TNA'
],
'members': [65]
},
{
'group': {
'id': 1,
'name': 'Super Administrators',
'description': 'DB: reserved group that provides full system access.',
'type': 1
}
},
{
'group': {
'id': 5,
'name': 'Administrators',
'description': 'General: members have access to admin backends in DB, DAM, Knowledge Base, and Public website. They pass most regular permissions checks.',
'type': 1
}
},
{
'group': {
'id': 2,
'name': 'Developers',
'description': 'DB: Special group reserved for backend system access.',
'type': 1
}
},
{
'group': {
'id': 7,
'name': 'Web Editors',
'description': 'Public Website: members can see most content and approve pages for publication.',
'type': 5
}
},
{
'group': {
'id': 8,
'name': 'Editors',
'description': 'DB: members can perform limited editorial tasks, such as managing lists (locales, countries, languages).',
'type': 1
}
},
{
'group': {
'id': 4,
'name': 'Users',
'description': 'DB: members can log-in, add and work on their own content, and view other content not marked as private.',
'type': 1
}
},
{
'group': {
'id': 10,
'name': 'DAM Editors',
'description': 'DAM: members can add, edit, and delete most content.',
'type': 2
}
},
{
'group': {
'id': 11,
'name': 'DAM Users',
'description': 'DAM: members can search and view content, as well as create their own private collections.',
'type': 2
}
},
{
'group': {
'name': 'KB Users',
'description': 'Knowledge Base: members can view and create content.',
'type': 4
}
},
{
'group': {
'name': 'Web Users',
'description': 'Public Website: members can only see their own content and create new pages (which must be approved by an editor before publication).',
'type': 5
}
},
]
remove_groups = [3, 6, 9, 15, 16]
remove_datasets = ['16226133-b1a0-4ecc-8905-39a4e8cb4751', 'd6398755-524b-4848-8cd9-c0a6838e840c']
print('Starting:')
orphans = Source.objects.filter(type=12, parent=None)
archives = Source.objects.filter(type=19)
for orphan in orphans:
for archive in archives:
if archive.short_name in orphan.short_name:
orphan.parent = archive
orphan.save()
# misspelt outliers: AS Messsina, AR Mallorce, AS Genova,
outliers = {
'c81bfda4-0ccd-483d-bc95-9d2d469c2f05': '125938f6-66ce-4dfa-a8cd-59d7e09e2dc0',
'6e04c235-aebe-4ec5-a616-34a072df09f2': 'ad3cf1d7-a288-4075-86d5-76376e0ea0fd',
'1a563c65-101d-4aa9-9dc7-44ee26e6110c': '539c24f3-0d27-4484-873b-a55d8c3608ce',
'48c5eb56-daaf-4c5c-b4bc-22fa46088501': '2dbbbdfa-6689-4485-a07a-61e3c1ac55e9',
'7114567b-d067-43a2-91d7-f4bf7f76b4b3': '7a902e65-9259-464a-8312-9020c96ebaa5',
}
for k, v in outliers.items():
obj = Source.objects.get(pk=k)
obj.parent = Source.objects.get(pk=v)
obj.save()
print('Orphans fixed')
for entry in entrysets:
if entry['group'].get('id') is not None:
group = Group.objects.get(pk=entry['group']['id'])
group.name = entry['group']['name']
group.save()
properties = group.properties
properties.type = entry['group']['type']
properties.description = entry['group']['description']
properties.save()
else:
group = Group()
group.name = entry['group']['name']
group.save()
GroupProperties.objects.create(group=group, type=entry['group']['type'], description=entry['group']['description'])
print('Group processed')
if entry.get('dataset') is not None:
entry['dataset']['dataset_usergroup'] = group
if entry['dataset'].get('id') is not None:
dataset = Set.objects.get(pk=entry['dataset'].pop('id'))
for attr, value in entry['dataset'].items():
setattr(dataset, attr, value)
dataset.save()
else:
dataset = Set(**entry['dataset'])
dataset.save()
print('Dataset processed')
if entry.get('archives') is not None:
for archive in entry['archives']:
fus = Source.objects.filter(type=12, parent__short_name=archive)
for fu in fus:
fu.primary_dataset = dataset
fu.save()
print('Archives processed')
if entry.get('members') is not None:
for member in entry['members']:
user = User.objects.get(pk=member)
user.groups.add(group.id)
profile = user.profile
profile.primary_group = group
profile.save()
print('Members processed')
for group in remove_groups:
obj = Group.objects.get(pk=group)
obj.delete()
print('Groups removed')
for set in remove_datasets:
if Set.objects.filter(pk=set).exists():
obj = Set.objects.get(pk=set)
obj.delete()
else:
print('Failed to delete ' + str(set))
print('Sets removed')
sources = Source.objects.filter(type=13)
for source in sources:
if source.parent is not None and source.parent.primary_dataset is not None:
source.primary_dataset = source.parent.primary_dataset
source.save()
print('Records updated with new primary dataset information')
return 'Done'
def project_add(request):
contact_clean()
if request.method == 'POST':
project_form = ProjectForm(request.POST)
contact_form = ContactForm(request.POST)
user_form = UserForm(request.POST)
if project_form.is_valid() and contact_form.is_valid(
) and user_form.is_valid():
# project
project_form.clean()
project_data = project_form.cleaned_data
project_group = Group()
project_group.name = project_data['name'] + '_admin'
project_group.save()
project = Project(name=project_data['name'],
web_site=project_data['web_site'],
admin_group=project_group)
# user
user_data = user_form.cleaned_data
# if User.objects.filter(username=user_data['username']).exists():
# raise forms.ValidationError(u'Username "%s" is already in use.' % user_data['username'])
# else:
user = User.objects.create_user(username=user_data['username'],
password=user_data['password'])
project_group.user_set.add(user)
# contact
contact_data = contact_form.cleaned_data
# if Person.objects.filter(email=contact_data['email']).exists():
# raise forms.ValidationError(u'Username "%s" is already in use.' % user_data['username'])
# else:
contact = Person(
firstname=contact_data['firstname'],
lastname=contact_data['lastname'],
email=contact_data['email'],
#telephone = contact_data['telephone'],
user=user)
contact.save()
project.save()
# add membership to new contact
role = Role.objects.get_or_create(name='admin')[0]
Membership(person=contact, project=project, role=role).save()
# automatically login
user = authenticate(username=user_data['username'],
password=user_data['password'])
login(request, user)
return HttpResponseRedirect("wireframe/")
else:
user_form = UserForm()
project_form = ProjectForm()
contact_form = ContactForm()
return render(
request, 'presentation/project_add.html', {
'project_form': project_form,
'contact_form': contact_form,
'user_form': user_form
})
def group():
superuser = Group()
superuser.name = 'Superuser'
superuser.save()
return superuser
def new_role(self, name):
group = Group()
group.name = name
group.save()
return False if group.pk is None else group
cursor.execute("DROP SCHEMA public CASCADE")
cursor.execute("CREATE SCHEMA public")
cursor.execute("GRANT ALL ON SCHEMA public TO postgres")
cursor.execute("GRANT ALL ON SCHEMA public TO public")
# make the migrations and migrate
management.call_command('makemigrations', 'account', 'catalog')
management.call_command('migrate')
# imports for our project
from account.models import FomoUser
from django.contrib.auth.models import Permission, Group
#Create Groups
g1 = Group()
g1.name = 'Admin'
g1.save()
for p in Permission.objects.all():
g1.permissions.add(p)
g2 = Group()
g2.name = 'Manager'
g2.save()
g2.permissions.add(Permission.objects.get(codename='add_logentry'))
g2.permissions.add(Permission.objects.get(codename='change_fomouser'))
g2.permissions.add(Permission.objects.get(codename='delete_logentry'))
g2.permissions.add(Permission.objects.get(codename='change_logentry'))
#create custom permissions
cursor.execute("DROP SCHEMA public CASCADE")
cursor.execute("CREATE SCHEMA public")
cursor.execute("GRANT ALL ON SCHEMA public TO postgres")
cursor.execute("GRANT ALL ON SCHEMA public TO public")
# migrate
management.call_command('makemigrations')
management.call_command('migrate')
# add groups
for data in (
('Managers', Permission.objects.all()),
('Customers', ()),
):
group = Group()
group.name = data[0]
group.save()
group.permissions.set(data[1])
# add users
for data in (
('Margo', 'Isabell', '*****@*****.**', 'misabell', 'mypass',
False, False, '465 N 300 W Apt 29', 'Provo', 'UT', '84601',
'479-802-9621', [
'Customers',
]),
('Jim', 'Fife', '*****@*****.**', 'primeguard68', 'mypass',
False, False, '12695 Strawberry Ridge Road', 'Bentonville', 'AR', '72712',
'479-898-3344', [
'Customers',
]),
def create_role(request):
role = Group()
role.name = request.POST.get("group_name")
role.save()
SystemRoleService.add_role_extendinfo(role)
print()
print('Creating permissions and groups...')
# delete the existing groups and permissions assigned to them
Group.objects.all().delete(
) # this also deletes everything in the association table between groups and permissions
# I'm not creating any permissions because I'm going to use the default ones that Django creates
# They are automatically created for each model class. For the account.User class, we get:
# account.add_user
# account.change_user
# account.delete_user
# manager group (managers have all permissions)
group_manager = Group()
group_manager.name = 'Manager'
group_manager.save()
for p in Permission.objects.all():
group_manager.permissions.add(p)
# SalesRep group (sales reps can change only catalog items)
group_salesrep = Group()
group_salesrep.name = 'SalesRep'
group_salesrep.save()
for p in Permission.objects.filter(content_type__app_label='catalog'):
group_salesrep.permissions.add(p)
# customer group (customers have no permissions)
group_customer = Group()
group_customer.name = 'Customer'
group_customer.save()
def create_groups_and_test_users(chief_editors_group_name, editors_group_name,
writers_group_name):
# django-reversion group name
REVERSION_GROUP_NAME = 'Reversion'
groups = (
# group name, permissions
(writers_group_name, \
['news.newsitem.change_newsitem', 'news.newsitem.change_status_to_new', \
'news.newsitem.change_status_to_draft', 'news.newsitem.change_status_to_ready']),
(editors_group_name, \
['news.newsitem.change_newsitem', 'news.newsitem.can_change_author', \
'news.newsitem.change_status_to_new', 'news.newsitem.change_status_to_draft', \
'news.newsitem.change_status_to_ready', 'news.newsitem.change_status_to_reviewed']),
(chief_editors_group_name, \
['news.newsitem.add_newsitem', 'news.newsitem.change_newsitem', 'news.newsitem.delete_newsitem', \
'news.newsitem.can_change_author', 'news.newsitem.can_change_editor', \
'news.newsitem.can_change_chief_editor', 'news.newsitem.change_status_to_new', \
'news.newsitem.change_status_to_draft', 'news.newsitem.change_status_to_ready', \
'news.newsitem.change_status_to_reviewed', 'news.newsitem.change_status_to_published']),
(REVERSION_GROUP_NAME, \
['reversion.version.add_version', 'reversion.version.change_version', 'reversion.version.delete_version'])
)
for group_name, group_permissions in groups:
try:
# Creating the group
group = Group()
group.name = group_name
group.save()
# Adding permissions
q = None
for group_permission in group_permissions:
app_label, model, permission_name = group_permission.split('.')
if q is None:
q = Q(content_type__app_label=app_label,
content_type__model=model,
codename=permission_name)
else:
q = q | Q(content_type__app_label=app_label,
content_type__model=model,
codename=permission_name)
permissions = Permission._default_manager.filter(q)
group.permissions.add(*permissions)
except Exception as e:
pass
users = (
# username, password, e-mail, first name, last name
('admin', 'test', '*****@*****.**', 'Test Admin', 'Test Admin', []),
('chief_editor', 'test', '*****@*****.**', 'Test Chief Editor', 'Test Chief Editor', \
[chief_editors_group_name, REVERSION_GROUP_NAME]),
('editor', 'test', '*****@*****.**', 'Test Editor', 'Test Editor', \
[editors_group_name, REVERSION_GROUP_NAME]),
('writer', 'test', '*****@*****.**', 'Test Writer', 'Test Writer', \
[writers_group_name, REVERSION_GROUP_NAME])
)
for username, password, email, first_name, last_name, groups in users:
try:
# Creating a new user
user = User()
user.username = username
user.set_password(password)
user.email = email
user.first_name = first_name
user.last_name = last_name
user.is_staff = True
if 'admin' == username:
user.is_superuser = True
user.save()
# Adding created user to groups
user_groups = Group._default_manager.filter(name__in=groups)
user.groups.add(*user_groups)
except Exception as e:
pass
def get_or_create_user(self, username, password):
""" create or update the User object """
# get user info from AD
userInfo = self.get_user_info(username, password)
# is there already a user?
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
if userInfo is not None:
user = User(username=username, password=password)
self.debug_write('create new user %s' % username)
user.save() #Creates initial user so groups can be manipulated
else:
return None
## update the user objects
# group mapping for the access rights
user.groups.clear() #Clears user groups in case of changes
for group in userInfo['idGroup']: #Adds all groups user is member of
if group in settings.AD_MEMBERSHIP_REQ:
try:
g=Group.objects.get(name=group)
except:
g=Group()
g.name=group
g.save()
user.groups.add(g)
user.groups.add(g)
if userInfo['isAdmin']:
user.is_staff = True
user.is_superuser = True
elif userInfo:
user.is_staff = True
user.is_superuser = False
else:
user.is_active = False
# personal data
user.first_name = userInfo['first_name']
user.last_name = userInfo['last_name']
user.email = userInfo['mail']
# cache the AD password
user.set_password('ldap authenticated') #puts in a dummy PW doesn't matter but use this to put a hash in
user.save()
return user
def get_user(self, user_id):
try:
return User.objects.get(pk=user_id)
except User.DoesNotExist:
return None
def debug_write(self,message):
""" handle debug messages """
if self.debugFile is not None:
fObj = open(self.debugFile, 'a')
now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
fObj.write("%s\t%s\n" % (now,message))
fObj.close()
def check_group(self,membership):
""" evaluate ADS group memberships """
self.debug_write("Evaluating group membership")
isValid = False
isAdmin = False
idGroup = []
pattern = re.compile(r'^CN=ID (?P<groupName>[\w|\d|\s]+),') #Our AD groups were mirrored with the Django groups but prefaced with "ID " (notice the space)
for group in membership:
groupMatch = pattern.match(group)
if groupMatch:
thisGroup = groupMatch.group('groupName')
idGroup.append(thisGroup)
if thisGroup in settings.AD_MEMBERSHIP_REQ:
isValid = True
if thisGroup in settings.AD_MEMBERSHIP_ADMIN:
isAdmin = True
if isAdmin:
self.debug_write('is admin user')
elif isValid:
self.debug_write('is normal user')
else:
self.debug_write('does not have the AD group membership needed')
return isAdmin, isValid, idGroup
def get_user_info(self, username, password):
""" get user info from ADS to a dictionary """
try:
userInfo = {
'username' : username,
'password' : password,
}
# prepare LDAP connection
ldap.set_option(ldap.OPT_X_TLS_CACERTFILE,settings.AD_CERT_FILE)
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT,ldap.OPT_X_TLS_NEVER) #This required to avoid CN mismatches
ldap.set_option(ldap.OPT_REFERRALS,0) # DO NOT TURN THIS OFF OR SEARCH WON'T WORK!
# initialize
self.debug_write('ldap.initialize...')
l = ldap.initialize(settings.AD_LDAP_URL)
l.set_option(ldap.OPT_PROTOCOL_VERSION, 3)
# bind
binddn = "%s@%s" % (username,settings.AD_NT4_DOMAIN)
self.debug_write('ldap.bind %s' % binddn)
l.bind_s(binddn,password)
# search
self.debug_write('search...')
result = l.search_ext_s(settings.AD_SEARCH_DN,ldap.SCOPE_SUBTREE,"sAMAccountName=%s" % username,settings.AD_SEARCH_FIELDS)[0][1]
self.debug_write("results in %s" % result)
# Validate that they are a member of review board group
if result.has_key('memberOf'):
membership = result['memberOf']
else:
self.debug_write('AD user has no group memberships')
return None
# user ADS Groups
isAdmin, isValid, idGroup = self.check_group(membership)
if not isValid:
return None
userInfo['isAdmin'] = isAdmin
userInfo['idGroup'] = idGroup
self.debug_write(idGroup)
# get user info from ADS
# get email
if result.has_key('mail'):
mail = result['mail'][0]
else:
mail = ""
userInfo['mail'] = mail
self.debug_write("mail=%s" % mail)
# get surname
if result.has_key('sn'):
last_name = result['sn'][0]
else:
last_name = None
userInfo['last_name'] = last_name
self.debug_write("last_name=%s" % last_name)
# get display name
if result.has_key('givenName'):
first_name = result['givenName'][0]
else:
first_name = None
userInfo['first_name'] = first_name
self.debug_write("first_name=%s" % first_name)
# LDAP unbind
l.unbind_s()
return userInfo
except Exception, e:
self.debug_write("exception caught!")
self.debug_write(e)
return None
os.environ['DJANGO_SETTINGS_MODULE'] = 'colheritage.settings'
import django
django.setup()
import homepage.models as hmod
import datetime
from django.contrib.auth.models import Group, Permission, ContentType
permission = Permission()
permission.codename = 'Admin'
permission.content_type = ContentType.objects.get(id=7)
permission.name = 'Super Privileges'
permission.save()
group = Group()
group.name = "Admin"
group.save()
group.permissions.add(permission)
permission = Permission.objects.get(id=94)
group.permissions.add(permission)
user = hmod.User()
user.username = '******'
user.set_password('asdf')
user.is_superuser = True
user.is_staff = True
user.first_name = ''
user.last_name = ''
user.email = ''
user.is_active = True
user.date_joined = datetime.datetime.now()
def get_default_staff_group() -> int:
group = Group()
group.name = 'store__staff_group__' + str(get_next_usable_pk(Group))
group.save()
return group.pk
#Get group permissions
for perm in group.permissions.values():
permIdList.append(perm.get('id'))
data['perm_id'] = permIdList
groupList.append(data)
except Exception,e:
groupList = []
return render_to_response('vmUser/group_manage.html',{"user":request.user,"location":[{"name":"Home","url":'/'},{"name":"User group management","url":'/groupmanage/?op=list'}],
"groupList":groupList,"permList":permList},
context_instance=RequestContext(request))
elif request.method == "POST":
op = request.POST.get('op')
if op == 'add' and request.user.has_perm('auth.add_group'):
try:
group = Group()
group.name = request.POST.get('name')
group.save()
permList = [ int(i) for i in request.POST.get('perm').split(',')]
for permId in permList:
perm = Permission.objects.get(id=permId)
group.permissions.add(perm)
group.save()
return JsonResponse({"code":200,"data":None,"msg":"User group added successfully"})
except Exception,e:
print e
return JsonResponse({"code":500,"data":None,"msg":"User group failed to add"})
if op in ['delete','modify'] and request.user.has_perm('VManagePlatform.change_group'):
try:
group = Group.objects.get(id=request.POST.get('id'))
except:
return JsonResponse({"code":500,"data":None,"msg":"Operation failed: User group does not exist"})
def add_user_group(name):
new_group = Group()
new_group.name = name
new_group.save()
return new_group
def mutate(root, info, name, permissions):
group = Group()
group.name = name
group.save()
group.permissions.set(permissions)
return AddGroup(group=group)
Group.objects.all().delete()
permission = Permission()
permission.codename = 'manager_rights'
permission.content_type = ContentType.objects.get(id=7)
permission.name = 'Has Manager Rights'
permission.save()
permission1 = Permission()
permission1.codename = 'admin_rights'
permission1.content_type = ContentType.objects.get(id=7)
permission1.name = 'Has Admin Rights'
permission1.save()
group1 = Group()
group1.name = "Admin"
group1.save()
group1.permissions.add(permission)
group1.permissions.add(permission1)
group2 = Group()
group2.name = "Managers"
group2.save()
group2.permissions.add(permission1)
group3 = Group()
group3.name = "Guest"
group3.save()
print('permissions initialized')
##########################################################################################
#########User
##### CREATE PERMISSIONS/GROUPS #####################
Permission.objects.all().delete()
Group.objects.all().delete()
permission = Permission()
permission.codename = 'manager_rights'
permission.content_type = ContentType.objects.get(id=7)
permission.name = 'Has Manager Rights'
permission.save()
group = Group()
group.name = "Managers"
group.save()
group.permissions.add(permission)
print('permissions initialized')
#Delete old users
hmod.SiteUser.objects.all().delete()
#create som users
###############################ADD FIRST USER ###############################
u = hmod.SiteUser()
u.name = "users"
u.first_name = "rodney"
u.last_name = "cox"
u.set_password("showtime")
u.username = "******"
cursor.execute("CREATE SCHEMA PUBLIC")
subprocess.call([sys.executable, "manage.py", "migrate"])
#### Create permissions/groups ######
Permission.objects.all().delete()
Group.objects.all().delete()
##Admin
permission = Permission()
permission.codename = 'admin_rights'
permission.content_type = ContentType.objects.get(id=7)
permission.name = 'AdminRights'
permission.save()
agroup = Group()
agroup.name = "Admin"
agroup.save()
agroup.permissions.add(permission)
subprocess.call([sys.executable, "manage.py", "migrate"])
###Manager
permission = Permission()
permission.codename = 'manager_rights'
permission.content_type = ContentType.objects.get(id=5)
permission.name = 'ManagerRights'
permission.save()
mgroup = Group()
mgroup.name = "Manager"
mgroup.save()
mgroup.permissions.add(permission)
cursor.execute("DROP SCHEMA public CASCADE")
cursor.execute("CREATE SCHEMA public")
cursor.execute("GRANT ALL ON SCHEMA public TO postgres")
cursor.execute("GRANT ALL ON SCHEMA public TO public")
# make the migrations and migrate
management.call_command('makemigrations', 'account', 'catalog')
management.call_command('migrate')
# imports for our project
from account.models import FomoUser
from django.contrib.auth.models import Permission, Group
#Create Groups
g1 = Group()
g1.name = 'Admin'
g1.save()
for p in Permission.objects.all():
g1.permissions.add(p)
g2 = Group()
g2.name = 'Manager'
g2.save()
g2.permissions.add(Permission.objects.get(codename='add_fomouser'))
g2.permissions.add(Permission.objects.get(codename='change_fomouser'))
g2.permissions.add(Permission.objects.get(codename='delete_fomouser'))
g2.permissions.add(Permission.objects.get(codename='add_logentry'))
g2.permissions.add(Permission.objects.get(codename='change_logentry'))
g2.permissions.add(Permission.objects.get(codename='delete_logentry'))
g2.permissions.add(
Permission.objects.filter(codename='add_bulkproduct').first())
cursor.execute("CREATE SCHEMA PUBLIC")
subprocess.call([sys.executable, "manage.py", "migrate"])
#Create groups and permissions
Permission.objects.all().delete()
Group.objects.all().delete()
permission3 = Permission()
permission3.codename = 'check_user'
permission3.content_type = ContentType.objects.get(id=8)
permission3.name = 'check_user'
permission3.save()
group3 = Group()
group3.name = "user"
group3.save()
group3.permissions.add(permission3)
permission2 = Permission()
permission2.codename = 'check_manager'
permission2.content_type = ContentType.objects.get(id=8)
permission2.name = 'check_manager'
permission2.save()
group2 = Group()
group2.name = "manager"
group2.save()
group2.permissions.add(permission2)
group2.permissions.add(permission3)
os.environ['DJANGO_SETTINGS_MODULE'] = 'test_dmp.settings'
import django
django.setup()
from django.contrib.auth import models as conmod
import homepage.models as hmod
from django.contrib.auth.models import Group, Permission, ContentType
permission = Permission()
permission.codename = 'super'
permission.content_type = ContentType.objects.get(id=7)
permission.name = 'Super Privileges'
permission.save()
group = Group()
group.name = "super"
group.save()
group.permissions.add(permission)
permission = Permission.objects.get(id=82)
group.permissions.add(permission)
user = hmod.User()
user.username = '******'
user.set_password('asdf')
user.is_superuser = True
user.is_staff = True
user.save()
group.user_set.add(user)
permission = Permission()
# for our project from django.contrib.auth.models import Permission, Group from datetime import datetime from decimal import Decimal import json as json from account import models as amod #account models from catalog import models as cmod #catalog models # Create some default permissions # Create our Groups g1 = Group() g1.name = 'Customer' g1.save() g1.permissions.add(Permission.objects.get(codename='add_fomouser')) g1.permissions.add(Permission.objects.get(codename='change_fomouser')) g2 = Group() g2.name = 'Employee' g2.save() g2.permissions.add(Permission.objects.get(codename='add_fomouser')) g2.permissions.add(Permission.objects.get(codename='change_fomouser')) g2.permissions.add(Permission.objects.get(codename='change_bulkproduct')) g3 = Group() g3.name = 'Manager' g3.save() g3.permissions.add(Permission.objects.get(codename='add_fomouser'))
def import_data():
# Initial Imports
# Processing model: django.contrib.auth.models.Permission
from django.contrib.auth.models import Permission
auth_permission_1 = Permission()
auth_permission_1.name = 'Can add email address'
auth_permission_1.content_type = ContentType.objects.get(
app_label="account", model="emailaddress")
auth_permission_1.codename = 'add_emailaddress'
auth_permission_1 = importer.save_or_locate(auth_permission_1)
auth_permission_2 = Permission()
auth_permission_2.name = 'Can change email address'
auth_permission_2.content_type = ContentType.objects.get(
app_label="account", model="emailaddress")
auth_permission_2.codename = 'change_emailaddress'
auth_permission_2 = importer.save_or_locate(auth_permission_2)
auth_permission_3 = Permission()
auth_permission_3.name = 'Can delete email address'
auth_permission_3.content_type = ContentType.objects.get(
app_label="account", model="emailaddress")
auth_permission_3.codename = 'delete_emailaddress'
auth_permission_3 = importer.save_or_locate(auth_permission_3)
auth_permission_4 = Permission()
auth_permission_4.name = 'Can view email address'
auth_permission_4.content_type = ContentType.objects.get(
app_label="account", model="emailaddress")
auth_permission_4.codename = 'view_emailaddress'
auth_permission_4 = importer.save_or_locate(auth_permission_4)
auth_permission_5 = Permission()
auth_permission_5.name = 'Can add email confirmation'
auth_permission_5.content_type = ContentType.objects.get(
app_label="account", model="emailconfirmation")
auth_permission_5.codename = 'add_emailconfirmation'
auth_permission_5 = importer.save_or_locate(auth_permission_5)
auth_permission_6 = Permission()
auth_permission_6.name = 'Can change email confirmation'
auth_permission_6.content_type = ContentType.objects.get(
app_label="account", model="emailconfirmation")
auth_permission_6.codename = 'change_emailconfirmation'
auth_permission_6 = importer.save_or_locate(auth_permission_6)
auth_permission_7 = Permission()
auth_permission_7.name = 'Can delete email confirmation'
auth_permission_7.content_type = ContentType.objects.get(
app_label="account", model="emailconfirmation")
auth_permission_7.codename = 'delete_emailconfirmation'
auth_permission_7 = importer.save_or_locate(auth_permission_7)
auth_permission_8 = Permission()
auth_permission_8.name = 'Can view email confirmation'
auth_permission_8.content_type = ContentType.objects.get(
app_label="account", model="emailconfirmation")
auth_permission_8.codename = 'view_emailconfirmation'
auth_permission_8 = importer.save_or_locate(auth_permission_8)
auth_permission_9 = Permission()
auth_permission_9.name = 'Can add log entry'
auth_permission_9.content_type = ContentType.objects.get(app_label="admin",
model="logentry")
auth_permission_9.codename = 'add_logentry'
auth_permission_9 = importer.save_or_locate(auth_permission_9)
auth_permission_10 = Permission()
auth_permission_10.name = 'Can change log entry'
auth_permission_10.content_type = ContentType.objects.get(
app_label="admin", model="logentry")
auth_permission_10.codename = 'change_logentry'
auth_permission_10 = importer.save_or_locate(auth_permission_10)
auth_permission_11 = Permission()
auth_permission_11.name = 'Can delete log entry'
auth_permission_11.content_type = ContentType.objects.get(
app_label="admin", model="logentry")
auth_permission_11.codename = 'delete_logentry'
auth_permission_11 = importer.save_or_locate(auth_permission_11)
auth_permission_12 = Permission()
auth_permission_12.name = 'Can view log entry'
auth_permission_12.content_type = ContentType.objects.get(
app_label="admin", model="logentry")
auth_permission_12.codename = 'view_logentry'
auth_permission_12 = importer.save_or_locate(auth_permission_12)
auth_permission_13 = Permission()
auth_permission_13.name = 'Can add social account'
auth_permission_13.content_type = ContentType.objects.get(
app_label="allauth", model="socialaccount")
auth_permission_13.codename = 'add_socialaccount'
auth_permission_13 = importer.save_or_locate(auth_permission_13)
auth_permission_14 = Permission()
auth_permission_14.name = 'Can change social account'
auth_permission_14.content_type = ContentType.objects.get(
app_label="allauth", model="socialaccount")
auth_permission_14.codename = 'change_socialaccount'
auth_permission_14 = importer.save_or_locate(auth_permission_14)
auth_permission_15 = Permission()
auth_permission_15.name = 'Can delete social account'
auth_permission_15.content_type = ContentType.objects.get(
app_label="allauth", model="socialaccount")
auth_permission_15.codename = 'delete_socialaccount'
auth_permission_15 = importer.save_or_locate(auth_permission_15)
auth_permission_16 = Permission()
auth_permission_16.name = 'Can view social account'
auth_permission_16.content_type = ContentType.objects.get(
app_label="allauth", model="socialaccount")
auth_permission_16.codename = 'view_socialaccount'
auth_permission_16 = importer.save_or_locate(auth_permission_16)
auth_permission_17 = Permission()
auth_permission_17.name = 'Can add social application'
auth_permission_17.content_type = ContentType.objects.get(
app_label="allauth", model="socialapp")
auth_permission_17.codename = 'add_socialapp'
auth_permission_17 = importer.save_or_locate(auth_permission_17)
auth_permission_18 = Permission()
auth_permission_18.name = 'Can change social application'
auth_permission_18.content_type = ContentType.objects.get(
app_label="allauth", model="socialapp")
auth_permission_18.codename = 'change_socialapp'
auth_permission_18 = importer.save_or_locate(auth_permission_18)
auth_permission_19 = Permission()
auth_permission_19.name = 'Can delete social application'
auth_permission_19.content_type = ContentType.objects.get(
app_label="allauth", model="socialapp")
auth_permission_19.codename = 'delete_socialapp'
auth_permission_19 = importer.save_or_locate(auth_permission_19)
auth_permission_20 = Permission()
auth_permission_20.name = 'Can view social application'
auth_permission_20.content_type = ContentType.objects.get(
app_label="allauth", model="socialapp")
auth_permission_20.codename = 'view_socialapp'
auth_permission_20 = importer.save_or_locate(auth_permission_20)
auth_permission_21 = Permission()
auth_permission_21.name = 'Can add social application token'
auth_permission_21.content_type = ContentType.objects.get(
app_label="allauth", model="socialtoken")
auth_permission_21.codename = 'add_socialtoken'
auth_permission_21 = importer.save_or_locate(auth_permission_21)
auth_permission_22 = Permission()
auth_permission_22.name = 'Can change social application token'
auth_permission_22.content_type = ContentType.objects.get(
app_label="allauth", model="socialtoken")
auth_permission_22.codename = 'change_socialtoken'
auth_permission_22 = importer.save_or_locate(auth_permission_22)
auth_permission_23 = Permission()
auth_permission_23.name = 'Can delete social application token'
auth_permission_23.content_type = ContentType.objects.get(
app_label="allauth", model="socialtoken")
auth_permission_23.codename = 'delete_socialtoken'
auth_permission_23 = importer.save_or_locate(auth_permission_23)
auth_permission_24 = Permission()
auth_permission_24.name = 'Can view social application token'
auth_permission_24.content_type = ContentType.objects.get(
app_label="allauth", model="socialtoken")
auth_permission_24.codename = 'view_socialtoken'
auth_permission_24 = importer.save_or_locate(auth_permission_24)
auth_permission_25 = Permission()
auth_permission_25.name = 'Can add group'
auth_permission_25.content_type = ContentType.objects.get(app_label="auth",
model="group")
auth_permission_25.codename = 'add_group'
auth_permission_25 = importer.save_or_locate(auth_permission_25)
auth_permission_26 = Permission()
auth_permission_26.name = 'Can change group'
auth_permission_26.content_type = ContentType.objects.get(app_label="auth",
model="group")
auth_permission_26.codename = 'change_group'
auth_permission_26 = importer.save_or_locate(auth_permission_26)
auth_permission_27 = Permission()
auth_permission_27.name = 'Can delete group'
auth_permission_27.content_type = ContentType.objects.get(app_label="auth",
model="group")
auth_permission_27.codename = 'delete_group'
auth_permission_27 = importer.save_or_locate(auth_permission_27)
auth_permission_28 = Permission()
auth_permission_28.name = 'Can view group'
auth_permission_28.content_type = ContentType.objects.get(app_label="auth",
model="group")
auth_permission_28.codename = 'view_group'
auth_permission_28 = importer.save_or_locate(auth_permission_28)
auth_permission_29 = Permission()
auth_permission_29.name = 'Can add permission'
auth_permission_29.content_type = ContentType.objects.get(
app_label="auth", model="permission")
auth_permission_29.codename = 'add_permission'
auth_permission_29 = importer.save_or_locate(auth_permission_29)
auth_permission_30 = Permission()
auth_permission_30.name = 'Can change permission'
auth_permission_30.content_type = ContentType.objects.get(
app_label="auth", model="permission")
auth_permission_30.codename = 'change_permission'
auth_permission_30 = importer.save_or_locate(auth_permission_30)
auth_permission_31 = Permission()
auth_permission_31.name = 'Can delete permission'
auth_permission_31.content_type = ContentType.objects.get(
app_label="auth", model="permission")
auth_permission_31.codename = 'delete_permission'
auth_permission_31 = importer.save_or_locate(auth_permission_31)
auth_permission_32 = Permission()
auth_permission_32.name = 'Can view permission'
auth_permission_32.content_type = ContentType.objects.get(
app_label="auth", model="permission")
auth_permission_32.codename = 'view_permission'
auth_permission_32 = importer.save_or_locate(auth_permission_32)
auth_permission_33 = Permission()
auth_permission_33.name = 'Can add user'
auth_permission_33.content_type = ContentType.objects.get(app_label="auth",
model="user")
auth_permission_33.codename = 'add_user'
auth_permission_33 = importer.save_or_locate(auth_permission_33)
auth_permission_34 = Permission()
auth_permission_34.name = 'Can change user'
auth_permission_34.content_type = ContentType.objects.get(app_label="auth",
model="user")
auth_permission_34.codename = 'change_user'
auth_permission_34 = importer.save_or_locate(auth_permission_34)
auth_permission_35 = Permission()
auth_permission_35.name = 'Can delete user'
auth_permission_35.content_type = ContentType.objects.get(app_label="auth",
model="user")
auth_permission_35.codename = 'delete_user'
auth_permission_35 = importer.save_or_locate(auth_permission_35)
auth_permission_36 = Permission()
auth_permission_36.name = 'Can view user'
auth_permission_36.content_type = ContentType.objects.get(app_label="auth",
model="user")
auth_permission_36.codename = 'view_user'
auth_permission_36 = importer.save_or_locate(auth_permission_36)
auth_permission_37 = Permission()
auth_permission_37.name = 'Can add Token'
auth_permission_37.content_type = ContentType.objects.get(
app_label="authtoken", model="token")
auth_permission_37.codename = 'add_token'
auth_permission_37 = importer.save_or_locate(auth_permission_37)
auth_permission_38 = Permission()
auth_permission_38.name = 'Can change Token'
auth_permission_38.content_type = ContentType.objects.get(
app_label="authtoken", model="token")
auth_permission_38.codename = 'change_token'
auth_permission_38 = importer.save_or_locate(auth_permission_38)
auth_permission_39 = Permission()
auth_permission_39.name = 'Can delete Token'
auth_permission_39.content_type = ContentType.objects.get(
app_label="authtoken", model="token")
auth_permission_39.codename = 'delete_token'
auth_permission_39 = importer.save_or_locate(auth_permission_39)
auth_permission_40 = Permission()
auth_permission_40.name = 'Can view Token'
auth_permission_40.content_type = ContentType.objects.get(
app_label="authtoken", model="token")
auth_permission_40.codename = 'view_token'
auth_permission_40 = importer.save_or_locate(auth_permission_40)
auth_permission_41 = Permission()
auth_permission_41.name = 'Can add content type'
auth_permission_41.content_type = ContentType.objects.get(
app_label="contenttypes", model="contenttype")
auth_permission_41.codename = 'add_contenttype'
auth_permission_41 = importer.save_or_locate(auth_permission_41)
auth_permission_42 = Permission()
auth_permission_42.name = 'Can change content type'
auth_permission_42.content_type = ContentType.objects.get(
app_label="contenttypes", model="contenttype")
auth_permission_42.codename = 'change_contenttype'
auth_permission_42 = importer.save_or_locate(auth_permission_42)
auth_permission_43 = Permission()
auth_permission_43.name = 'Can delete content type'
auth_permission_43.content_type = ContentType.objects.get(
app_label="contenttypes", model="contenttype")
auth_permission_43.codename = 'delete_contenttype'
auth_permission_43 = importer.save_or_locate(auth_permission_43)
auth_permission_44 = Permission()
auth_permission_44.name = 'Can view content type'
auth_permission_44.content_type = ContentType.objects.get(
app_label="contenttypes", model="contenttype")
auth_permission_44.codename = 'view_contenttype'
auth_permission_44 = importer.save_or_locate(auth_permission_44)
auth_permission_45 = Permission()
auth_permission_45.name = 'Can add Dataset'
auth_permission_45.content_type = ContentType.objects.get(
app_label="datastore", model="datasetmodel")
auth_permission_45.codename = 'add_datasetmodel'
auth_permission_45 = importer.save_or_locate(auth_permission_45)
auth_permission_46 = Permission()
auth_permission_46.name = 'Can change Dataset'
auth_permission_46.content_type = ContentType.objects.get(
app_label="datastore", model="datasetmodel")
auth_permission_46.codename = 'change_datasetmodel'
auth_permission_46 = importer.save_or_locate(auth_permission_46)
auth_permission_47 = Permission()
auth_permission_47.name = 'Can delete Dataset'
auth_permission_47.content_type = ContentType.objects.get(
app_label="datastore", model="datasetmodel")
auth_permission_47.codename = 'delete_datasetmodel'
auth_permission_47 = importer.save_or_locate(auth_permission_47)
auth_permission_48 = Permission()
auth_permission_48.name = 'Can view Dataset'
auth_permission_48.content_type = ContentType.objects.get(
app_label="datastore", model="datasetmodel")
auth_permission_48.codename = 'view_datasetmodel'
auth_permission_48 = importer.save_or_locate(auth_permission_48)
auth_permission_49 = Permission()
auth_permission_49.name = 'Can add Entry'
auth_permission_49.content_type = ContentType.objects.get(
app_label="datastore", model="entrymodel")
auth_permission_49.codename = 'add_entrymodel'
auth_permission_49 = importer.save_or_locate(auth_permission_49)
auth_permission_50 = Permission()
auth_permission_50.name = 'Can change Entry'
auth_permission_50.content_type = ContentType.objects.get(
app_label="datastore", model="entrymodel")
auth_permission_50.codename = 'change_entrymodel'
auth_permission_50 = importer.save_or_locate(auth_permission_50)
auth_permission_51 = Permission()
auth_permission_51.name = 'Can delete Entry'
auth_permission_51.content_type = ContentType.objects.get(
app_label="datastore", model="entrymodel")
auth_permission_51.codename = 'delete_entrymodel'
auth_permission_51 = importer.save_or_locate(auth_permission_51)
auth_permission_52 = Permission()
auth_permission_52.name = 'Can view Entry'
auth_permission_52.content_type = ContentType.objects.get(
app_label="datastore", model="entrymodel")
auth_permission_52.codename = 'view_entrymodel'
auth_permission_52 = importer.save_or_locate(auth_permission_52)
auth_permission_53 = Permission()
auth_permission_53.name = 'Can add schema model'
auth_permission_53.content_type = ContentType.objects.get(
app_label="datastore", model="schemamodel")
auth_permission_53.codename = 'add_schemamodel'
auth_permission_53 = importer.save_or_locate(auth_permission_53)
auth_permission_54 = Permission()
auth_permission_54.name = 'Can change schema model'
auth_permission_54.content_type = ContentType.objects.get(
app_label="datastore", model="schemamodel")
auth_permission_54.codename = 'change_schemamodel'
auth_permission_54 = importer.save_or_locate(auth_permission_54)
auth_permission_55 = Permission()
auth_permission_55.name = 'Can delete schema model'
auth_permission_55.content_type = ContentType.objects.get(
app_label="datastore", model="schemamodel")
auth_permission_55.codename = 'delete_schemamodel'
auth_permission_55 = importer.save_or_locate(auth_permission_55)
auth_permission_56 = Permission()
auth_permission_56.name = 'Can view schema model'
auth_permission_56.content_type = ContentType.objects.get(
app_label="datastore", model="schemamodel")
auth_permission_56.codename = 'view_schemamodel'
auth_permission_56 = importer.save_or_locate(auth_permission_56)
auth_permission_57 = Permission()
auth_permission_57.name = 'Can add Argument'
auth_permission_57.content_type = ContentType.objects.get(
app_label="engine", model="argumentmodel")
auth_permission_57.codename = 'add_argumentmodel'
auth_permission_57 = importer.save_or_locate(auth_permission_57)
auth_permission_58 = Permission()
auth_permission_58.name = 'Can change Argument'
auth_permission_58.content_type = ContentType.objects.get(
app_label="engine", model="argumentmodel")
auth_permission_58.codename = 'change_argumentmodel'
auth_permission_58 = importer.save_or_locate(auth_permission_58)
auth_permission_59 = Permission()
auth_permission_59.name = 'Can delete Argument'
auth_permission_59.content_type = ContentType.objects.get(
app_label="engine", model="argumentmodel")
auth_permission_59.codename = 'delete_argumentmodel'
auth_permission_59 = importer.save_or_locate(auth_permission_59)
auth_permission_60 = Permission()
auth_permission_60.name = 'Can view Argument'
auth_permission_60.content_type = ContentType.objects.get(
app_label="engine", model="argumentmodel")
auth_permission_60.codename = 'view_argumentmodel'
auth_permission_60 = importer.save_or_locate(auth_permission_60)
auth_permission_61 = Permission()
auth_permission_61.name = 'Can add execution model'
auth_permission_61.content_type = ContentType.objects.get(
app_label="engine", model="executionmodel")
auth_permission_61.codename = 'add_executionmodel'
auth_permission_61 = importer.save_or_locate(auth_permission_61)
auth_permission_62 = Permission()
auth_permission_62.name = 'Can change execution model'
auth_permission_62.content_type = ContentType.objects.get(
app_label="engine", model="executionmodel")
auth_permission_62.codename = 'change_executionmodel'
auth_permission_62 = importer.save_or_locate(auth_permission_62)
auth_permission_63 = Permission()
auth_permission_63.name = 'Can delete execution model'
auth_permission_63.content_type = ContentType.objects.get(
app_label="engine", model="executionmodel")
auth_permission_63.codename = 'delete_executionmodel'
auth_permission_63 = importer.save_or_locate(auth_permission_63)
auth_permission_64 = Permission()
auth_permission_64.name = 'Can view execution model'
auth_permission_64.content_type = ContentType.objects.get(
app_label="engine", model="executionmodel")
auth_permission_64.codename = 'view_executionmodel'
auth_permission_64 = importer.save_or_locate(auth_permission_64)
auth_permission_65 = Permission()
auth_permission_65.name = 'Can add Process'
auth_permission_65.content_type = ContentType.objects.get(
app_label="engine", model="processmodel")
auth_permission_65.codename = 'add_processmodel'
auth_permission_65 = importer.save_or_locate(auth_permission_65)
auth_permission_66 = Permission()
auth_permission_66.name = 'Can change Process'
auth_permission_66.content_type = ContentType.objects.get(
app_label="engine", model="processmodel")
auth_permission_66.codename = 'change_processmodel'
auth_permission_66 = importer.save_or_locate(auth_permission_66)
auth_permission_67 = Permission()
auth_permission_67.name = 'Can delete Process'
auth_permission_67.content_type = ContentType.objects.get(
app_label="engine", model="processmodel")
auth_permission_67.codename = 'delete_processmodel'
auth_permission_67 = importer.save_or_locate(auth_permission_67)
auth_permission_68 = Permission()
auth_permission_68.name = 'Can view Process'
auth_permission_68.content_type = ContentType.objects.get(
app_label="engine", model="processmodel")
auth_permission_68.codename = 'view_processmodel'
auth_permission_68 = importer.save_or_locate(auth_permission_68)
auth_permission_69 = Permission()
auth_permission_69.name = 'Can add Airport'
auth_permission_69.content_type = ContentType.objects.get(
app_label="mdm", model="airportmodel")
auth_permission_69.codename = 'add_airportmodel'
auth_permission_69 = importer.save_or_locate(auth_permission_69)
auth_permission_70 = Permission()
auth_permission_70.name = 'Can change Airport'
auth_permission_70.content_type = ContentType.objects.get(
app_label="mdm", model="airportmodel")
auth_permission_70.codename = 'change_airportmodel'
auth_permission_70 = importer.save_or_locate(auth_permission_70)
auth_permission_71 = Permission()
auth_permission_71.name = 'Can delete Airport'
auth_permission_71.content_type = ContentType.objects.get(
app_label="mdm", model="airportmodel")
auth_permission_71.codename = 'delete_airportmodel'
auth_permission_71 = importer.save_or_locate(auth_permission_71)
auth_permission_72 = Permission()
auth_permission_72.name = 'Can view Airport'
auth_permission_72.content_type = ContentType.objects.get(
app_label="mdm", model="airportmodel")
auth_permission_72.codename = 'view_airportmodel'
auth_permission_72 = importer.save_or_locate(auth_permission_72)
auth_permission_73 = Permission()
auth_permission_73.name = 'Can add Bagtype'
auth_permission_73.content_type = ContentType.objects.get(
app_label="mdm", model="bagtypemodel")
auth_permission_73.codename = 'add_bagtypemodel'
auth_permission_73 = importer.save_or_locate(auth_permission_73)
auth_permission_74 = Permission()
auth_permission_74.name = 'Can change Bagtype'
auth_permission_74.content_type = ContentType.objects.get(
app_label="mdm", model="bagtypemodel")
auth_permission_74.codename = 'change_bagtypemodel'
auth_permission_74 = importer.save_or_locate(auth_permission_74)
auth_permission_75 = Permission()
auth_permission_75.name = 'Can delete Bagtype'
auth_permission_75.content_type = ContentType.objects.get(
app_label="mdm", model="bagtypemodel")
auth_permission_75.codename = 'delete_bagtypemodel'
auth_permission_75 = importer.save_or_locate(auth_permission_75)
auth_permission_76 = Permission()
auth_permission_76.name = 'Can view Bagtype'
auth_permission_76.content_type = ContentType.objects.get(
app_label="mdm", model="bagtypemodel")
auth_permission_76.codename = 'view_bagtypemodel'
auth_permission_76 = importer.save_or_locate(auth_permission_76)
auth_permission_77 = Permission()
auth_permission_77.name = 'Can add Board'
auth_permission_77.content_type = ContentType.objects.get(
app_label="mdm", model="boardmodel")
auth_permission_77.codename = 'add_boardmodel'
auth_permission_77 = importer.save_or_locate(auth_permission_77)
auth_permission_78 = Permission()
auth_permission_78.name = 'Can change Board'
auth_permission_78.content_type = ContentType.objects.get(
app_label="mdm", model="boardmodel")
auth_permission_78.codename = 'change_boardmodel'
auth_permission_78 = importer.save_or_locate(auth_permission_78)
auth_permission_79 = Permission()
auth_permission_79.name = 'Can delete Board'
auth_permission_79.content_type = ContentType.objects.get(
app_label="mdm", model="boardmodel")
auth_permission_79.codename = 'delete_boardmodel'
auth_permission_79 = importer.save_or_locate(auth_permission_79)
auth_permission_80 = Permission()
auth_permission_80.name = 'Can view Board'
auth_permission_80.content_type = ContentType.objects.get(
app_label="mdm", model="boardmodel")
auth_permission_80.codename = 'view_boardmodel'
auth_permission_80 = importer.save_or_locate(auth_permission_80)
auth_permission_81 = Permission()
auth_permission_81.name = 'Can add Flight provider'
auth_permission_81.content_type = ContentType.objects.get(
app_label="mdm", model="flightprovidermodel")
auth_permission_81.codename = 'add_flightprovidermodel'
auth_permission_81 = importer.save_or_locate(auth_permission_81)
auth_permission_82 = Permission()
auth_permission_82.name = 'Can change Flight provider'
auth_permission_82.content_type = ContentType.objects.get(
app_label="mdm", model="flightprovidermodel")
auth_permission_82.codename = 'change_flightprovidermodel'
auth_permission_82 = importer.save_or_locate(auth_permission_82)
auth_permission_83 = Permission()
auth_permission_83.name = 'Can delete Flight provider'
auth_permission_83.content_type = ContentType.objects.get(
app_label="mdm", model="flightprovidermodel")
auth_permission_83.codename = 'delete_flightprovidermodel'
auth_permission_83 = importer.save_or_locate(auth_permission_83)
auth_permission_84 = Permission()
auth_permission_84.name = 'Can view Flight provider'
auth_permission_84.content_type = ContentType.objects.get(
app_label="mdm", model="flightprovidermodel")
auth_permission_84.codename = 'view_flightprovidermodel'
auth_permission_84 = importer.save_or_locate(auth_permission_84)
auth_permission_85 = Permission()
auth_permission_85.name = 'Can add Hotel'
auth_permission_85.content_type = ContentType.objects.get(
app_label="mdm", model="hotelmodel")
auth_permission_85.codename = 'add_hotelmodel'
auth_permission_85 = importer.save_or_locate(auth_permission_85)
auth_permission_86 = Permission()
auth_permission_86.name = 'Can change Hotel'
auth_permission_86.content_type = ContentType.objects.get(
app_label="mdm", model="hotelmodel")
auth_permission_86.codename = 'change_hotelmodel'
auth_permission_86 = importer.save_or_locate(auth_permission_86)
auth_permission_87 = Permission()
auth_permission_87.name = 'Can delete Hotel'
auth_permission_87.content_type = ContentType.objects.get(
app_label="mdm", model="hotelmodel")
auth_permission_87.codename = 'delete_hotelmodel'
auth_permission_87 = importer.save_or_locate(auth_permission_87)
auth_permission_88 = Permission()
auth_permission_88.name = 'Can view Hotel'
auth_permission_88.content_type = ContentType.objects.get(
app_label="mdm", model="hotelmodel")
auth_permission_88.codename = 'view_hotelmodel'
auth_permission_88 = importer.save_or_locate(auth_permission_88)
auth_permission_89 = Permission()
auth_permission_89.name = 'Can add Market'
auth_permission_89.content_type = ContentType.objects.get(
app_label="mdm", model="marketmodel")
auth_permission_89.codename = 'add_marketmodel'
auth_permission_89 = importer.save_or_locate(auth_permission_89)
auth_permission_90 = Permission()
auth_permission_90.name = 'Can change Market'
auth_permission_90.content_type = ContentType.objects.get(
app_label="mdm", model="marketmodel")
auth_permission_90.codename = 'change_marketmodel'
auth_permission_90 = importer.save_or_locate(auth_permission_90)
auth_permission_91 = Permission()
auth_permission_91.name = 'Can delete Market'
auth_permission_91.content_type = ContentType.objects.get(
app_label="mdm", model="marketmodel")
auth_permission_91.codename = 'delete_marketmodel'
auth_permission_91 = importer.save_or_locate(auth_permission_91)
auth_permission_92 = Permission()
auth_permission_92.name = 'Can view Market'
auth_permission_92.content_type = ContentType.objects.get(
app_label="mdm", model="marketmodel")
auth_permission_92.codename = 'view_marketmodel'
auth_permission_92 = importer.save_or_locate(auth_permission_92)
auth_permission_93 = Permission()
auth_permission_93.name = 'Can add Roomtype'
auth_permission_93.content_type = ContentType.objects.get(
app_label="mdm", model="roomtypemodel")
auth_permission_93.codename = 'add_roomtypemodel'
auth_permission_93 = importer.save_or_locate(auth_permission_93)
auth_permission_94 = Permission()
auth_permission_94.name = 'Can change Roomtype'
auth_permission_94.content_type = ContentType.objects.get(
app_label="mdm", model="roomtypemodel")
auth_permission_94.codename = 'change_roomtypemodel'
auth_permission_94 = importer.save_or_locate(auth_permission_94)
auth_permission_95 = Permission()
auth_permission_95.name = 'Can delete Roomtype'
auth_permission_95.content_type = ContentType.objects.get(
app_label="mdm", model="roomtypemodel")
auth_permission_95.codename = 'delete_roomtypemodel'
auth_permission_95 = importer.save_or_locate(auth_permission_95)
auth_permission_96 = Permission()
auth_permission_96.name = 'Can view Roomtype'
auth_permission_96.content_type = ContentType.objects.get(
app_label="mdm", model="roomtypemodel")
auth_permission_96.codename = 'view_roomtypemodel'
auth_permission_96 = importer.save_or_locate(auth_permission_96)
auth_permission_97 = Permission()
auth_permission_97.name = 'Can add Supplier'
auth_permission_97.content_type = ContentType.objects.get(
app_label="mdm", model="suppliermodel")
auth_permission_97.codename = 'add_suppliermodel'
auth_permission_97 = importer.save_or_locate(auth_permission_97)
auth_permission_98 = Permission()
auth_permission_98.name = 'Can change Supplier'
auth_permission_98.content_type = ContentType.objects.get(
app_label="mdm", model="suppliermodel")
auth_permission_98.codename = 'change_suppliermodel'
auth_permission_98 = importer.save_or_locate(auth_permission_98)
auth_permission_99 = Permission()
auth_permission_99.name = 'Can delete Supplier'
auth_permission_99.content_type = ContentType.objects.get(
app_label="mdm", model="suppliermodel")
auth_permission_99.codename = 'delete_suppliermodel'
auth_permission_99 = importer.save_or_locate(auth_permission_99)
auth_permission_100 = Permission()
auth_permission_100.name = 'Can view Supplier'
auth_permission_100.content_type = ContentType.objects.get(
app_label="mdm", model="suppliermodel")
auth_permission_100.codename = 'view_suppliermodel'
auth_permission_100 = importer.save_or_locate(auth_permission_100)
auth_permission_101 = Permission()
auth_permission_101.name = 'Can add session'
auth_permission_101.content_type = ContentType.objects.get(
app_label="sessions", model="session")
auth_permission_101.codename = 'add_session'
auth_permission_101 = importer.save_or_locate(auth_permission_101)
auth_permission_102 = Permission()
auth_permission_102.name = 'Can change session'
auth_permission_102.content_type = ContentType.objects.get(
app_label="sessions", model="session")
auth_permission_102.codename = 'change_session'
auth_permission_102 = importer.save_or_locate(auth_permission_102)
auth_permission_103 = Permission()
auth_permission_103.name = 'Can delete session'
auth_permission_103.content_type = ContentType.objects.get(
app_label="sessions", model="session")
auth_permission_103.codename = 'delete_session'
auth_permission_103 = importer.save_or_locate(auth_permission_103)
auth_permission_104 = Permission()
auth_permission_104.name = 'Can view session'
auth_permission_104.content_type = ContentType.objects.get(
app_label="sessions", model="session")
auth_permission_104.codename = 'view_session'
auth_permission_104 = importer.save_or_locate(auth_permission_104)
auth_permission_105 = Permission()
auth_permission_105.name = 'Can add site'
auth_permission_105.content_type = ContentType.objects.get(
app_label="sites", model="site")
auth_permission_105.codename = 'add_site'
auth_permission_105 = importer.save_or_locate(auth_permission_105)
auth_permission_106 = Permission()
auth_permission_106.name = 'Can change site'
auth_permission_106.content_type = ContentType.objects.get(
app_label="sites", model="site")
auth_permission_106.codename = 'change_site'
auth_permission_106 = importer.save_or_locate(auth_permission_106)
auth_permission_107 = Permission()
auth_permission_107.name = 'Can delete site'
auth_permission_107.content_type = ContentType.objects.get(
app_label="sites", model="site")
auth_permission_107.codename = 'delete_site'
auth_permission_107 = importer.save_or_locate(auth_permission_107)
auth_permission_108 = Permission()
auth_permission_108.name = 'Can view site'
auth_permission_108.content_type = ContentType.objects.get(
app_label="sites", model="site")
auth_permission_108.codename = 'view_site'
auth_permission_108 = importer.save_or_locate(auth_permission_108)
# Processing model: django.contrib.auth.models.Group
from django.contrib.auth.models import Group
auth_group_1 = Group()
auth_group_1.name = 'reviewer'
auth_group_1 = importer.save_or_locate(auth_group_1)
auth_group_1.permissions.add(auth_permission_57)
auth_group_1.permissions.add(auth_permission_58)
auth_group_1.permissions.add(auth_permission_59)
auth_group_1.permissions.add(auth_permission_61)
auth_group_1.permissions.add(auth_permission_62)
auth_group_1.permissions.add(auth_permission_63)
auth_group_1.permissions.add(auth_permission_65)
auth_group_1.permissions.add(auth_permission_66)
auth_group_1.permissions.add(auth_permission_67)
auth_group_2 = Group()
auth_group_2.name = 'contentmanager'
auth_group_2 = importer.save_or_locate(auth_group_2)
auth_group_3 = Group()
auth_group_3.name = 'datarecorder'
auth_group_3 = importer.save_or_locate(auth_group_3)
auth_group_4 = Group()
auth_group_4.name = 'analyst'
auth_group_4 = importer.save_or_locate(auth_group_4)
auth_group_5 = Group()
auth_group_5.name = 'customer'
auth_group_5 = importer.save_or_locate(auth_group_5)
# Processing model: django.contrib.auth.models.User
from django.contrib.auth.models import User
auth_user_1 = User()
auth_user_1.password = '******'
auth_user_1.last_login = None
auth_user_1.is_superuser = False
auth_user_1.username = '******'
auth_user_1.first_name = 'Customer'
auth_user_1.last_name = 'Test'
auth_user_1.email = '*****@*****.**'
auth_user_1.is_staff = False
auth_user_1.is_active = True
auth_user_1.date_joined = dateutil.parser.parse(
"2018-08-06T21:46:41+00:00")
auth_user_1 = importer.save_or_locate(auth_user_1)
auth_user_1.groups.add(auth_group_5)
auth_user_2 = User()
auth_user_2.password = '******'
auth_user_2.last_login = None
auth_user_2.is_superuser = False
auth_user_2.username = '******'
auth_user_2.first_name = 'Administrator'
auth_user_2.last_name = 'Test'
auth_user_2.email = '*****@*****.**'
auth_user_2.is_staff = False
auth_user_2.is_active = True
auth_user_2.date_joined = dateutil.parser.parse(
"2018-08-06T21:48:06+00:00")
auth_user_2 = importer.save_or_locate(auth_user_2)
auth_user_2.groups.add(auth_group_1)
auth_user_2.groups.add(auth_group_2)
auth_user_2.groups.add(auth_group_3)
auth_user_3 = User()
auth_user_3.password = '******'
auth_user_3.last_login = dateutil.parser.parse(
"2018-08-07T16:19:41.407710+00:00")
auth_user_3.is_superuser = True
auth_user_3.username = '******'
auth_user_3.first_name = 'Gergely'
auth_user_3.last_name = 'Kurinyecz'
auth_user_3.email = '*****@*****.**'
auth_user_3.is_staff = True
auth_user_3.is_active = True
auth_user_3.date_joined = dateutil.parser.parse(
"2018-08-06T21:41:05+00:00")
auth_user_3 = importer.save_or_locate(auth_user_3)
auth_user_4 = User()
auth_user_4.password = '******'
auth_user_4.last_login = dateutil.parser.parse(
"2018-08-28T17:31:53.948139+00:00")
auth_user_4.is_superuser = True
auth_user_4.username = '******'
auth_user_4.first_name = 'László'
auth_user_4.last_name = 'Hegedűs'
auth_user_4.email = '*****@*****.**'
auth_user_4.is_staff = True
auth_user_4.is_active = True
auth_user_4.date_joined = dateutil.parser.parse(
"2018-08-06T21:37:42+00:00")
auth_user_4 = importer.save_or_locate(auth_user_4)
def import_data():
# Initial Imports
from django.contrib.auth.models import Group
# Processing model: opencourse.courses.models.City
from opencourse.courses.models import City
courses_city_1 = City()
courses_city_1.codepostal = None
courses_city_1.name = "London"
courses_city_1.name_en = "London"
courses_city_1.name_fr = "Londres"
courses_city_1.latitude_south = None
courses_city_1.latitude_north = None
courses_city_1.longitude_west = None
courses_city_1.longitude_east = None
courses_city_1.latitude_southa = None
courses_city_1.latitude_northa = None
courses_city_1.longitude_westa = None
courses_city_1.longitude_easta = None
courses_city_1.category_1 = None
courses_city_1.category_2 = None
courses_city_1 = importer.save_or_locate(courses_city_1)
courses_city_2 = City()
courses_city_2.codepostal = None
courses_city_2.name = "Paris"
courses_city_2.name_en = "Paris"
courses_city_2.name_fr = "Paris"
courses_city_2.latitude_south = None
courses_city_2.latitude_north = None
courses_city_2.longitude_west = None
courses_city_2.longitude_east = None
courses_city_2.latitude_southa = None
courses_city_2.latitude_northa = None
courses_city_2.longitude_westa = None
courses_city_2.longitude_easta = None
courses_city_2.category_1 = None
courses_city_2.category_2 = None
courses_city_2 = importer.save_or_locate(courses_city_2)
courses_city_3 = City()
courses_city_3.codepostal = None
courses_city_3.name = "Washington"
courses_city_3.name_en = "Washington"
courses_city_3.name_fr = "Washington"
courses_city_3.latitude_south = None
courses_city_3.latitude_north = None
courses_city_3.longitude_west = None
courses_city_3.longitude_east = None
courses_city_3.latitude_southa = None
courses_city_3.latitude_northa = None
courses_city_3.longitude_westa = None
courses_city_3.longitude_easta = None
courses_city_3.category_1 = None
courses_city_3.category_2 = None
courses_city_3 = importer.save_or_locate(courses_city_3)
courses_city_4 = City()
courses_city_4.codepostal = None
courses_city_4.name = "Berlin"
courses_city_4.name_en = "Berlin"
courses_city_4.name_fr = "Berlin"
courses_city_4.latitude_south = None
courses_city_4.latitude_north = None
courses_city_4.longitude_west = None
courses_city_4.longitude_east = None
courses_city_4.latitude_southa = None
courses_city_4.latitude_northa = None
courses_city_4.longitude_westa = None
courses_city_4.longitude_easta = None
courses_city_4.category_1 = None
courses_city_4.category_2 = None
courses_city_4 = importer.save_or_locate(courses_city_4)
courses_city_5 = City()
courses_city_5.codepostal = None
courses_city_5.name = "Stockholm"
courses_city_5.name_en = "Stockholm"
courses_city_5.name_fr = "Stockholm"
courses_city_5.latitude_south = None
courses_city_5.latitude_north = None
courses_city_5.longitude_west = None
courses_city_5.longitude_east = None
courses_city_5.latitude_southa = None
courses_city_5.latitude_northa = None
courses_city_5.longitude_westa = None
courses_city_5.longitude_easta = None
courses_city_5.category_1 = None
courses_city_5.category_2 = None
courses_city_5 = importer.save_or_locate(courses_city_5)
# Processing model: opencourse.courses.models.CourseLevel
from opencourse.courses.models import CourseLevel
courses_courselevel_1 = CourseLevel()
courses_courselevel_1.name = "Beginner"
courses_courselevel_1.name_en = "Beginner"
courses_courselevel_1.name_fr = "Débutant"
courses_courselevel_1.description = None
courses_courselevel_1 = importer.save_or_locate(courses_courselevel_1)
courses_courselevel_2 = CourseLevel()
courses_courselevel_2.name = "Intermediate"
courses_courselevel_2.name_en = "Intermediate"
courses_courselevel_2.name_fr = "Moyen"
courses_courselevel_2.description = None
courses_courselevel_2 = importer.save_or_locate(courses_courselevel_2)
courses_courselevel_3 = CourseLevel()
courses_courselevel_3.name = "Advanced"
courses_courselevel_3.name_en = "Advanced"
courses_courselevel_3.name_fr = "Avancé"
courses_courselevel_3.description = None
courses_courselevel_3 = importer.save_or_locate(courses_courselevel_3)
# Processing model: opencourse.courses.models.CourseDuration
from opencourse.courses.models import CourseDuration
courses_courseduration_1 = CourseDuration()
courses_courseduration_1.duration = 30
courses_courseduration_1 = importer.save_or_locate(
courses_courseduration_1)
courses_courseduration_2 = CourseDuration()
courses_courseduration_2.duration = 45
courses_courseduration_2 = importer.save_or_locate(
courses_courseduration_2)
courses_courseduration_3 = CourseDuration()
courses_courseduration_3.duration = 60
courses_courseduration_3 = importer.save_or_locate(
courses_courseduration_3)
courses_courseduration_4 = CourseDuration()
courses_courseduration_4.duration = 90
courses_courseduration_4 = importer.save_or_locate(
courses_courseduration_4)
courses_courseduration_5 = CourseDuration()
courses_courseduration_5.duration = 120
courses_courseduration_5 = importer.save_or_locate(
courses_courseduration_5)
# Processing model: opencourse.courses.models.CourseAge
from opencourse.courses.models import CourseAge
courses_courseage_1 = CourseAge()
courses_courseage_1.max = None
courses_courseage_1.name = "Infants (0-3 years old)"
courses_courseage_1.name_en = "Infants (0-3 years old)"
courses_courseage_1.name_fr = "Nourrissons (0-3 ans)"
courses_courseage_1 = importer.save_or_locate(courses_courseage_1)
courses_courseage_2 = CourseAge()
courses_courseage_2.max = None
courses_courseage_2.name = "Preschool children (4-6 years old)"
courses_courseage_2.name_en = "Preschool children (4-6 years old)"
courses_courseage_2.name_fr = "Enfants d'âge préscolaire (4-6 ans)"
courses_courseage_2 = importer.save_or_locate(courses_courseage_2)
courses_courseage_3 = CourseAge()
courses_courseage_3.max = None
courses_courseage_3.name = "Children (7-12 years old)"
courses_courseage_3.name_en = "Children (7-12 years old)"
courses_courseage_3.name_fr = "Enfants (7-12 ans)"
courses_courseage_3 = importer.save_or_locate(courses_courseage_3)
courses_courseage_4 = CourseAge()
courses_courseage_4.max = None
courses_courseage_4.name = "Teenagers (13-17 years old)"
courses_courseage_4.name_en = "Teenagers (13-17 years old)"
courses_courseage_4.name_fr = "Adolescents (13-17 ans)"
courses_courseage_4 = importer.save_or_locate(courses_courseage_4)
courses_courseage_5 = CourseAge()
courses_courseage_5.max = None
courses_courseage_5.name = "Adults (18-64 years old)"
courses_courseage_5.name_en = "Adults (18-64 years old)"
courses_courseage_5.name_fr = "Adultes (18-64 ans)"
courses_courseage_5 = importer.save_or_locate(courses_courseage_5)
courses_courseage_6 = CourseAge()
courses_courseage_6.max = None
courses_courseage_6.name = "Seniors (65+ years old)"
courses_courseage_6.name_en = "Seniors (65+ years old)"
courses_courseage_6.name_fr = "Aînés (65 ans)"
courses_courseage_6 = importer.save_or_locate(courses_courseage_6)
# Processing model: opencourse.courses.models.CourseArea
from opencourse.courses.models import CourseArea
courses_coursearea_1 = CourseArea()
courses_coursearea_1.name = "Math"
courses_coursearea_1.name_en = "Math"
courses_coursearea_1.name_fr = "Math"
courses_coursearea_1.description = None
courses_coursearea_1 = importer.save_or_locate(courses_coursearea_1)
courses_coursearea_2 = CourseArea()
courses_coursearea_2.name = "Physics"
courses_coursearea_2.name_en = "Physics"
courses_coursearea_2.name_fr = "La physique"
courses_coursearea_2.description = None
courses_coursearea_2 = importer.save_or_locate(courses_coursearea_2)
courses_coursearea_3 = CourseArea()
courses_coursearea_3.name = "Chemistry"
courses_coursearea_3.name_en = "Chemistry"
courses_coursearea_3.name_fr = "Chimie"
courses_coursearea_3.description = None
courses_coursearea_3 = importer.save_or_locate(courses_coursearea_3)
courses_coursearea_4 = CourseArea()
courses_coursearea_4.name = "Biology"
courses_coursearea_4.name_en = "Biology"
courses_coursearea_4.name_fr = "La biologie"
courses_coursearea_4.description = None
courses_coursearea_4 = importer.save_or_locate(courses_coursearea_4)
# Processing model: opencourse.courses.models.CourseLanguage
from opencourse.courses.models import CourseLanguage
courses_courselanguage_1 = CourseLanguage()
courses_courselanguage_1.name = "English"
courses_courselanguage_1.name_en = "English"
courses_courselanguage_1.name_fr = "Anglais"
courses_courselanguage_1.tag = None
courses_courselanguage_1 = importer.save_or_locate(
courses_courselanguage_1)
courses_courselanguage_2 = CourseLanguage()
courses_courselanguage_2.name = "French"
courses_courselanguage_2.name_en = "French"
courses_courselanguage_2.name_fr = "Le français"
courses_courselanguage_2.tag = None
courses_courselanguage_2 = importer.save_or_locate(
courses_courselanguage_2)
courses_courselanguage_3 = CourseLanguage()
courses_courselanguage_3.name = "Arabic"
courses_courselanguage_3.name_en = "Arabic"
courses_courselanguage_3.name_fr = "Arabe"
courses_courselanguage_3.tag = None
courses_courselanguage_3 = importer.save_or_locate(
courses_courselanguage_3)
courses_courselanguage_4 = CourseLanguage()
courses_courselanguage_4.name = "Spanish"
courses_courselanguage_4.name_en = "Spanish"
courses_courselanguage_4.name_fr = "Espagnol"
courses_courselanguage_4.tag = None
courses_courselanguage_4 = importer.save_or_locate(
courses_courselanguage_4)
courses_courselanguage_5 = CourseLanguage()
courses_courselanguage_5.name = "Chinese"
courses_courselanguage_5.name_en = "Chinese"
courses_courselanguage_5.name_fr = "Japonais"
courses_courselanguage_5.tag = None
courses_courselanguage_5 = importer.save_or_locate(
courses_courselanguage_5)
courses_courselanguage_6 = CourseLanguage()
courses_courselanguage_6.name = "Hindi"
courses_courselanguage_6.name_en = "Hindi"
courses_courselanguage_6.name_fr = "Hindi"
courses_courselanguage_6.tag = None
courses_courselanguage_6 = importer.save_or_locate(
courses_courselanguage_6)
courses_courselanguage_7 = CourseLanguage()
courses_courselanguage_7.name = "Russian"
courses_courselanguage_7.name_en = "Russian"
courses_courselanguage_7.name_fr = "Russe"
courses_courselanguage_7.tag = None
courses_courselanguage_7 = importer.save_or_locate(
courses_courselanguage_7)
# Processing model: opencourse.courses.models.CourseLocationType
from opencourse.courses.models import CourseLocationType
courses_courselocationtype_1 = CourseLocationType()
courses_courselocationtype_1.name = "Teacher's"
courses_courselocationtype_1.name_en = "Teacher's"
courses_courselocationtype_1.name_fr = "Chez l'enseignant"
courses_courselocationtype_1 = importer.save_or_locate(
courses_courselocationtype_1)
courses_courselocationtype_2 = CourseLocationType()
courses_courselocationtype_2.name = "Students's"
courses_courselocationtype_2.name_en = "Students's"
courses_courselocationtype_2.name_fr = "Étudiant"
courses_courselocationtype_2 = importer.save_or_locate(
courses_courselocationtype_2)
courses_courselocationtype_3 = CourseLocationType()
courses_courselocationtype_3.name = "Via webcam"
courses_courselocationtype_3.name_en = "Via webcam"
courses_courselocationtype_3.name_fr = "Par webcam"
courses_courselocationtype_3 = importer.save_or_locate(
courses_courselocationtype_3)
# Processing model: opencourse.courses.models.Currency
from opencourse.courses.models import Currency
courses_currency_1 = Currency()
courses_currency_1.name = "Moroccan dirham"
courses_currency_1.iso_code = "MAD"
courses_currency_1.symbol = ".د.م"
courses_currency_1 = importer.save_or_locate(courses_currency_1)
courses_currency_2 = Currency()
courses_currency_2.name = "US dollar"
courses_currency_2.iso_code = "USD"
courses_currency_2.symbol = "$"
courses_currency_2 = importer.save_or_locate(courses_currency_2)
courses_currency_3 = Currency()
courses_currency_3.name = "Euro"
courses_currency_3.iso_code = "EUR"
courses_currency_3.symbol = "€"
courses_currency_3 = importer.save_or_locate(courses_currency_3)
# Processing model: opencourse.profiles.models.User
from opencourse.profiles.models import User
profiles_user_1 = User()
profiles_user_1.password = (
"pbkdf2_sha256$180000$cwXsrztq2kJE$S0uNCeGQ+FvIIi/LlodoNOIBkurUaDpFLoPpstMEetA="
)
profiles_user_1.last_login = dateutil.parser.parse(
"2020-05-10T20:46:18.956512+00:00")
profiles_user_1.is_superuser = True
profiles_user_1.username = "******"
profiles_user_1.first_name = ""
profiles_user_1.last_name = ""
profiles_user_1.email = "*****@*****.**"
profiles_user_1.is_staff = True
profiles_user_1.is_active = True
profiles_user_1.date_joined = dateutil.parser.parse(
"2020-05-10T20:19:13.787163+00:00")
profiles_user_1 = importer.save_or_locate(profiles_user_1)
profiles_user_2 = User()
profiles_user_2.password = (
"pbkdf2_sha256$180000$jQbED5mRC3FC$rGHmLPbEnbCrOGGHpIxdbpEjAWH76Dj4auzItGjxy3Y="
)
profiles_user_2.last_login = dateutil.parser.parse(
"2020-05-10T20:20:06.664503+00:00")
profiles_user_2.is_superuser = True
profiles_user_2.username = "******"
profiles_user_2.first_name = ""
profiles_user_2.last_name = ""
profiles_user_2.email = "*****@*****.**"
profiles_user_2.is_staff = True
profiles_user_2.is_active = True
profiles_user_2.date_joined = dateutil.parser.parse(
"2020-05-10T20:19:57.067332+00:00")
profiles_user_2 = importer.save_or_locate(profiles_user_2)
profiles_user_3 = User()
profiles_user_3.password = (
"pbkdf2_sha256$180000$GPo9wAK6xKK7$NERotmMpKK7hKesccmfbreFEjUBtlB+iMk1n1lR/mvc="
)
profiles_user_3.last_login = dateutil.parser.parse(
"2020-05-10T20:31:45.395920+00:00")
profiles_user_3.is_superuser = False
profiles_user_3.username = "******"
profiles_user_3.first_name = ""
profiles_user_3.last_name = ""
profiles_user_3.email = "*****@*****.**"
profiles_user_3.is_staff = False
profiles_user_3.is_active = True
profiles_user_3.date_joined = dateutil.parser.parse(
"2020-05-10T20:31:18.694372+00:00")
profiles_user_3 = importer.save_or_locate(profiles_user_3)
# Processing model: opencourse.profiles.models.Student
from opencourse.profiles.models import Student
profiles_student_1 = Student()
profiles_student_1.user = profiles_user_3
profiles_student_1.picture = ""
profiles_student_1.email_verified = False
profiles_student_1.first_name_ar = None
profiles_student_1.last_name_ar = None
profiles_student_1.address = None
profiles_student_1.city = None
profiles_student_1.dob = None
profiles_student_1.edulevel = None
profiles_student_1.tel = ""
profiles_student_1.whatsapp = None
profiles_student_1.email = None
profiles_student_1.dateadd = None
profiles_student_1.contacts_requests = 0
profiles_student_1 = importer.save_or_locate(profiles_student_1)
# Processing model: opencourse.profiles.models.Professor
from opencourse.profiles.models import Professor
profiles_professor_1 = Professor()
profiles_professor_1.user = profiles_user_1
profiles_professor_1.picture = ""
profiles_professor_1.email_verified = False
profiles_professor_1.first_name_ar = None
profiles_professor_1.last_name_ar = None
profiles_professor_1.address = None
profiles_professor_1.city = None
profiles_professor_1.dob = None
profiles_professor_1.edulevel = None
profiles_professor_1.tel = ""
profiles_professor_1.whatsapp = None
profiles_professor_1.email = None
profiles_professor_1.dateadd = None
profiles_professor_1.contacts_requests = 0
profiles_professor_1.bio = None
profiles_professor_1.yearsexperience = None
profiles_professor_1.act_position = None
profiles_professor_1.dateexpir = None
profiles_professor_1.listed = None
profiles_professor_1.feespaid = None
profiles_professor_1 = importer.save_or_locate(profiles_professor_1)
# Processing model: opencourse.profiles.models.Review
from opencourse.profiles.models import Review
profiles_review_1 = Review()
profiles_review_1.professor = profiles_professor_1
profiles_review_1.score = 5
profiles_review_1.text = "Крутой курс, нравится"
profiles_review_1.content_type = ContentType.objects.get(
app_label="profiles", model="professor")
profiles_review_1.author_id = 1
profiles_review_1 = importer.save_or_locate(profiles_review_1)
profiles_review_2 = Review()
profiles_review_2.professor = profiles_professor_1
profiles_review_2.score = 5
profiles_review_2.text = "Хороший курс"
profiles_review_2.content_type = ContentType.objects.get(
app_label="profiles", model="professor")
profiles_review_2.author_id = 1
profiles_review_2 = importer.save_or_locate(profiles_review_2)
profiles_review_3 = Review()
profiles_review_3.professor = profiles_professor_1
profiles_review_3.score = 2
profiles_review_3.text = "bad course!"
profiles_review_3.content_type = ContentType.objects.get(
app_label="profiles", model="professor")
profiles_review_3.author_id = 1
profiles_review_3 = importer.save_or_locate(profiles_review_3)
# Processing model: allauth.account.models.EmailAddress
from allauth.account.models import EmailAddress
account_emailaddress_1 = EmailAddress()
account_emailaddress_1.user = profiles_user_1
account_emailaddress_1.email = "*****@*****.**"
account_emailaddress_1.verified = True
account_emailaddress_1.primary = True
account_emailaddress_1 = importer.save_or_locate(account_emailaddress_1)
account_emailaddress_2 = EmailAddress()
account_emailaddress_2.user = profiles_user_3
account_emailaddress_2.email = "*****@*****.**"
account_emailaddress_2.verified = True
account_emailaddress_2.primary = True
account_emailaddress_2 = importer.save_or_locate(account_emailaddress_2)
# Processing model: opencourse.courses.models.Course
from opencourse.courses.models import Course
courses_course_1 = Course()
courses_course_1.professor = profiles_professor_1
courses_course_1.city = courses_city_1
courses_course_1.title = "Algebra for beginners"
courses_course_1.title_ar = None
courses_course_1.descrip = "Good course"
courses_course_1.extrainfo = None
courses_course_1.payactive = None
courses_course_1.active = None
courses_course_1.dateexp = None
courses_course_1.starthostdate = None
courses_course_1.endhostdate = None
courses_course_1.hosted = None
courses_course_1.hostactive = None
courses_course_1.level = courses_courselevel_1
courses_course_1.duration = courses_courseduration_1
courses_course_1 = importer.save_or_locate(courses_course_1)
courses_course_1.age.add(courses_courseage_1)
courses_course_1.area.add(courses_coursearea_1)
courses_course_1.language.add(courses_courselanguage_1)
courses_course_2 = Course()
courses_course_2.professor = profiles_professor_1
courses_course_2.city = courses_city_2
courses_course_2.title = "Термодинамика"
courses_course_2.title_ar = None
courses_course_2.descrip = "Лучший курс."
courses_course_2.extrainfo = None
courses_course_2.payactive = None
courses_course_2.active = None
courses_course_2.dateexp = None
courses_course_2.starthostdate = None
courses_course_2.endhostdate = None
courses_course_2.hosted = None
courses_course_2.hostactive = None
courses_course_2.level = courses_courselevel_1
courses_course_2.duration = courses_courseduration_1
courses_course_2 = importer.save_or_locate(courses_course_2)
courses_course_2.age.add(courses_courseage_1)
courses_course_2.area.add(courses_coursearea_2)
courses_course_2.language.add(courses_courselanguage_7)
# Processing model: opencourse.courses.models.CourseLocation
from opencourse.courses.models import CourseLocation
courses_courselocation_1 = CourseLocation()
courses_courselocation_1.location_type = courses_courselocationtype_1
courses_courselocation_1.course = courses_course_1
courses_courselocation_1.description = None
courses_courselocation_1.price = 1
courses_courselocation_1.currency = courses_currency_1
courses_courselocation_1.number_sessions = None
courses_courselocation_1.coursestartdate = None
courses_courselocation_1.courseenddate = None
courses_courselocation_1 = importer.save_or_locate(
courses_courselocation_1)
courses_courselocation_2 = CourseLocation()
courses_courselocation_2.location_type = courses_courselocationtype_1
courses_courselocation_2.course = courses_course_2
courses_courselocation_2.description = None
courses_courselocation_2.price = 1
courses_courselocation_2.currency = courses_currency_2
courses_courselocation_2.number_sessions = None
courses_courselocation_2.coursestartdate = None
courses_courselocation_2.courseenddate = None
courses_courselocation_2 = importer.save_or_locate(
courses_courselocation_2)
# Processing model: django.contrib.auth.models.Group
from django.contrib.auth.models import Group
from django.contrib.auth.models import Permission
professor_permission = Permission.objects.get(
codename="access_professor_pages")
students_permission = Permission.objects.get(
codename="access_student_pages")
auth_group_1 = Group()
auth_group_1.name = "Students"
auth_group_1 = importer.save_or_locate(auth_group_1)
auth_group_1.permissions.add(students_permission)
auth_group_2 = Group()
auth_group_2.name = "Professors"
auth_group_2 = importer.save_or_locate(auth_group_2)
auth_group_2.permissions.add(professor_permission)
auth_group_2.permissions.add(students_permission)
# Re-processing model: opencourse.profiles.models.User
profiles_user_1.groups.add(auth_group_2)
profiles_user_3.groups.add(auth_group_1)
# Processing model: opencourse.courses.models.HandoutSection
from opencourse.courses.models import HandoutSection
courses_handoutsection_1 = HandoutSection()
courses_handoutsection_1.name = "Lectures"
courses_handoutsection_1 = importer.save_or_locate(
courses_handoutsection_1)
courses_handoutsection_2 = HandoutSection()
courses_handoutsection_2.name = "Practice"
courses_handoutsection_2 = importer.save_or_locate(
courses_handoutsection_2)
courses_handoutsection_3 = HandoutSection()
courses_handoutsection_3.name = "Exams"
courses_handoutsection_3 = importer.save_or_locate(
courses_handoutsection_3)
for i in notifications:
a = college.models.custom_notice()
a.title = i
a.description = ''
alphabet = 'qwertyui opasdfg hjklzxcvbnm '
for i in xrange(int(random.random() * 799)):
a.description += random.choice(alphabet)
a.save()
print '......................................',
print 'done'
#make groups
print 'Groups',
for i in groupnames:
g1 = Group()
g1.name = i
g1.save()
print '......................................',
print 'done'
#add course types
print 'Course Type',
for i in course_types:
a = college.models.course_type()
a.name = i
a.save()
print '......................................',
print 'done'
#add courses
print 'Courses',
####################################### Groups #######################################
#Delete old groups
Group.objects.all().delete()
#Create new groups, Admin, Manager, Guest
for data in [
['Admin'],
['Manager'],
['Guest'],
]:
#create group, set name
g = Group()
g.name = data[0]
#save
g.save()
####################################### Permission #######################################
permissions = Permission.objects.all()
# Give admin permission
for p in permissions:
g = Group.objects.get(name="Admin")
g.permissions.add(p)
g.save()
["1782 S. Ashland Ridge dr.", "Herriman", "UT", "47483", "USA"],
["4484 W. 344 S.", "Salt Lake", "UT", "84848", "USA"],
["4555 W. 566 S.", "hahaha", "NY", "44555", "USA"],
["34343 W. 884444 S.", "Provo", "UT", "84333", "USA"],
]:
a = hmod.Address()
a.street1 = data[0]
a.city = data[1]
a.state = data[2]
a.zip_code = data[3]
a.country = data[4]
a.save()
################################### CREATE PERMISSIONS/GROUPS
g1 = Group()
g1.name = "Admin"
g1.save()
g2 = Group()
g2.name = 'Manager'
g2.save()
g3 = Group()
g3.name = 'Agent'
g3.save()
g4 = Group()
g4.name = 'Customer'
g4.save()
############################ ADD Permissions to Groups
Group.objects.all().delete()
AdminPermission = Permission()
AdminPermission.codename = 'admin_rights'
AdminPermission.content_type = ContentType.objects.get(id=7)
AdminPermission.name = 'Has Admin Rights'
AdminPermission.save()
ManagerPermission = Permission()
ManagerPermission.codename = 'manager_rights'
ManagerPermission.content_type = ContentType.objects.get(id=7)
ManagerPermission.name = 'Has Manager Rights'
ManagerPermission.save()
AdminGroup = Group()
AdminGroup.name = "AdminGroup"
AdminGroup.save()
AdminGroup.permissions.add(AdminPermission)
AdminGroup.permissions.add(ManagerPermission)
ManagerGroup = Group()
ManagerGroup.name = "ManagerGroup"
ManagerGroup.save()
ManagerGroup.permissions.add(ManagerPermission)
GuestGroup = Group()
GuestGroup.name = "GuestGroup"
GuestGroup.save()
print('permissions initialized')
def get_default_limited_customer_group() -> int:
group = Group()
group.name = 'store__limited_customer_group__' + str(
get_next_usable_pk(Group))
group.save()
return group.pk
