def save_similar_groups_into_database(filename='tmp/groups.csv'):
"""
Saves the group data from a .csv file into the database.
:param filename: – a string name of .csv file with group information
"""
with open(filename, 'r') as f:
reader = csv.reader(f)
groups = list(reader)
# An array of groups to save into the database
group_instances = []
# Fill the list of groups
for group in tqdm(groups[1:]):
name = group[0]
common = group[1]
gid = group[2]
group_instance = Group(gid=gid)
group_instance.name = name
group_instance.common_users = common
group_instances.append(group_instance)
# Add all into the database
db.session.add_all(group_instances)
db.session.commit()
def seed_groups():
user1 = User.query.get(1)
user2 = User.query.get(2)
user3 = User.query.get(3)
group1 = Group(name="Gryffindor")
db.session.add(group1)
group2 = Group(name="Ravenclaw")
db.session.add(group2)
group3 = Group(name="Hufflepuff")
db.session.add(group3)
group4 = Group(name="Slytherin")
db.session.add(group4)
user1.groups.append(group1)
user1.groups.append(group2)
user1.groups.append(group3)
user2.groups.append(group1)
user2.groups.append(group2)
user2.groups.append(group3)
user3.groups.append(group1)
user3.groups.append(group2)
user3.groups.append(group3)
db.session.commit()
def moderation():
if current_user.role == 'admin':
groups = Group.query.all()
admins = User.query.filter_by(role='admin').all()
current_time = {}
create_moderator_form = CreateModerForm()
for group in groups:
current_time[group.name] = datetime.now() + timedelta(hours=int(group.time_zone)) - timedelta(hours=int(Config.SERVER_TIME_ZONE))
if create_moderator_form.validate_on_submit():
if create_moderator_form.submit.data and create_moderator_form.validate():
for group in create_moderator_form.group.data:
gr = Group.query.get(group.id)
us = User.query.get(create_moderator_form.user.data.id)
gr.moderators.append(us)
db.session.commit()
return redirect(request.referrer)
create_group_form = CreateGroupForm()
if create_group_form.validate_on_submit():
if create_group_form.submit.data and create_group_form.validate():
group = Group()
group.name = create_group_form.name.data
db.session.add(group)
db.session.commit()
return redirect(request.referrer)
return render_template('admin/moderation.html', groups=groups, create_group_form=create_group_form,
create_moderator_form=create_moderator_form, current_time=current_time)
else:
return redirect(url_for('main.index'))
def add_group_form(form):
"""
Create a new Group table
:param form:
:return: if the group can be added, return the id of the group, else return False
"""
name = form.name.data
if Group.from_name(name) is not None:
flash("Ce groupe existe déjà", "danger")
return False
is_private = (form.is_private.data == 'private')
password = form.password.data
if not password and is_private:
flash("Vous devez mettre un mot de passe pour un groupe privé",
"danger")
return False
elif len(password) > 10:
flash("Veuillez rentrer un mot de passe de moins de 10 caractères",
"warning")
return False
db.session.add(
Group(name=name,
is_private=is_private,
password=password,
manager_id=current_user.id))
group_id = Group.from_name(name).id
db.session.add(Participate(group_id=group_id, member_id=current_user.id))
db.session.commit()
return group_id
def test_mass_delete(self):
from app.models import Group
g1 = Group(name="g1", project_id=self.project1._id)
g1.save()
h1 = Host(fqdn="host1", group_id=g1._id)
h1.save()
h2 = Host(fqdn="host2", group_id=g1._id)
h2.save()
h3 = Host(fqdn="host3", group_id=g1._id)
h3.save()
h4 = Host(fqdn="host4", group_id=g1._id)
h4.save()
r = self.post_json("/api/v1/hosts/mass_delete",
{"host_ids": [str(h2._id), str(h3._id)]})
self.assertEqual(200, r.status_code)
data = json.loads(r.data)
self.assertIn("data", data)
hosts_data = data["data"]
self.assertIn("hosts", hosts_data)
hosts_data = hosts_data["hosts"]
self.assertIs(list, type(hosts_data))
self.assertEqual(2, len(hosts_data))
deleted_hosts = Host.find({"_id": {"$in": [h2._id, h3._id]}})
self.assertEqual(0, deleted_hosts.count())
g1 = Group.find_one({"_id": g1._id})
self.assertItemsEqual([h1._id, h4._id], g1.host_ids)
def init_database():
# applies all alembic migrations
upgrade()
Group.establish_enemies()
yield db
db.drop_all()
def deploy():
"""部署"""
from flask_migrate import upgrade
from app.models import Role, User, Group, Tag
upgrade()
Role.insert_roles()
User.add_self_follows()
Group.insert_groups()
Tag.insert_tags()
def post():
form = GroupForm() # need to create a form
if form.validate_on_submit():
new_group = Group()
new_group.leader_id = request.json["leader_id"]
form.populate_obj(new_group)
db.session.add(new_group)
db.session.commit()
return new_group.to_dict()
return "Bad Data"
def get_group_list(itchat):
'''
获取群列表，并将其插入到 group 数据库中
:param itchat:
:return:
'''
room_list = itchat.get_chatrooms()
room_names = [room.NickName for room in room_list]
Group.create_group_from_name_list(room_names)
return room_names
def test_delete_group(self):
self.test_create_group()
group = Group.find_one({"name": "group1"})
r = self.delete("/api/v1/groups/%s" % group._id)
self.assertEqual(r.status_code, 200)
data = json.loads(r.data)
self.assertIn("data", data)
group_data = data["data"]
self.assertEqual(group_data["_id"], None)
group = Group.find_one({"_id": group._id})
self.assertIsNone(group)
def addGroup(name):
"""Add group to database.
args:
name: string
"""
group = Group()
group.name = name
group.members.append(current_user)
db.session.add(group)
db.session.commit()
return group.id
def create_group():
form = GroupRegistrationForm()
if form.validate_on_submit():
group = Group(group_name=form.group_name.data,
owner_id=current_user.id)
group.set_password(form.password.data)
db.session.add(group)
# add the current user to the group
current_user.group = group
db.session.commit()
return redirect(url_for('group'))
return render_template("group_register.html", form=form)
def permission_add():
'''/admin/Permission/add'''
form = AddpermissionForm()
if form.validate_on_submit():
group = Group.query.filter_by(name=form.name.data).first()
if not group:
Group.insert_group(form.name.data, form.description.data)
return jsonify({'code': 1, 'msg': '添加成功!'})
else:
return jsonify({'code': 0, 'msg': '组名已存在!'})
return render_template('admin/permission/add.html', form=form)
def deploy():
"""Build Roles and migrate/upgrade the database(?)
"""
print("Inserting Roles...")
Role.insert_roles()
Group.insert_groups()
print("Finished!")
return
def add_group():
form = AddGroupForm()
if form.validate_on_submit():
gid = form.gid.data
group = Group(gid)
group.user_id = g.user.id
db.session.add(group)
db.session.commit()
run_watching()
return redirect(url_for('index'))
def groups():
method = request.method
if method == 'GET':
# Get all Groups
groups = Group.query.order_by(Group.createdAt.desc())
return {"groups": [group.to_dict() for group in groups]}
elif method == 'POST':
# Add a new Group
group_name = request.json["groupName"]
group = Group(name=group_name)
db.session.add(group)
db.session.commit()
return jsonify(group.to_dict())
def add_group(request):
login = login_verify(request, None, True)
if login:
return login
if request.method == 'POST':
name = request.POST.get('name', '')
user = Group(name=name)
user.save()
return HttpResponseRedirect('/list_groups/')
else:
form = AddGroupForm()
context = {'form': form}
return render(request, 'app/add_group.html', context)
def create_groups(groups):
"""Add groups to db"""
for group in groups:
grp = Group(
code=group['code'],
active=bool(group['active']),
)
db.session.add(grp)
db.session.commit()
for module in group['modules']:
m = Module.query.filter_by(code=module).first()
grp.add_module_to_group(m)
db.session.commit()
def groups():
if request.method == "POST":
name = request.args['name']
if name:
group = Group(name=name)
group.save()
response = {'id': group.id, 'name': group.name}
return render_template("basic.html", data=response)
else:
return render_template("basic.html",
data={
'id': -1,
'name': "none"
})
def test_get_groups(self):
'''
Test case to check if all groups are returned by the get_groups function
'''
self.new_group.save_group()
test_group = Group(name="Product Pitches")
test_group.save_group()
gotten_groups = Group.get_groups()
self.assertTrue(len(gotten_groups) == len(Group.query.all()))
def addGroup():
if current_user.group.is_admin:
form = CreateGroupForm()
if form.validate_on_submit():
group = Group(group_name=form.group_name.data)
group.group_email = form.group_email.data
group.group_password = form.group_password.data
group.is_admin = form.group_is_admin.data
db.session.add(group)
db.session.commit()
flash('Congratulations, you created the group {}'.format(
group.group_name))
return redirect(url_for('user', username=current_user.username))
return render_template('add_group.html', form=form, title='Add Group')
return redirect(url_for('index'))
def create(self, data):
self.add_base_info(data)
user = user_service.create_user(data['username'], data['password'])
group = Group.find_by_id(data['group_id'])
if group is None:
group = Group(id=data['group_id'])
group.add_to_db()
student = Student(fio=data['fio'],
fullname=data['fullname'],
admission_year=data['admission_year'],
group_id=group.id)
student.account = user
student.add_to_db()
db.session.commit()
return data
def show(group_id=None):
from app.models import Group
if group_id is None:
query = {}
if "_filter" in request.values:
name_filter = request.values["_filter"]
if len(name_filter) >= 2:
query["name"] = {"$regex": "^%s" % name_filter}
groups = Group.find(query)
else:
group_id = resolve_id(group_id)
groups = Group.find({"$or": [{"_id": group_id}, {"name": group_id}]})
data = paginated_data(groups.sort("name"))
return json_response(data)
def change_view(self, request, object_id, form_url='', extra_context=None):
person = Person.objects.get(id=object_id)
enable_ldap_connection = LdapConn.enable()
exists_in_ldap = None
groups = None
suggested_ldap_name = ''
suggested_ldap_email = ''
if enable_ldap_connection:
exists_in_ldap = Person.exists_in_ldap( person.ldap_user_name )
groups = Group.all()
suggested_ldap_name = Person.suggested_name(object_id)
if hasattr(settings, 'LDAP_DOMAIN_MAIL') and settings.LDAP_DOMAIN_MAIL:
suggested_ldap_email = "{}@{}".format(suggested_ldap_name,
settings.LDAP_DOMAIN_MAIL)
else:
messages.warning(request, _('ldap_without_connection'))
context = {'suggested_ldap_name': suggested_ldap_name,
'suggested_ldap_email': suggested_ldap_email,
'groups': groups,
'hide_save_box': (not enable_ldap_connection),
'exists_in_ldap': exists_in_ldap }
return super(PersonAdmin, self).change_view(request, object_id,'',context)
def create_student(self, data):
user = user_service.create_user(data['username'], data['password'])
group = Group.find_by_id(data['group_id'])
if group is None:
group = Group(id=data['group_id'])
group.add_to_db()
student = Student(lastname=data['lastname'],
firstname=data['firstname'],
patronymic=data['patronymic'],
rank=data['rank'],
admission_year=data['admission_year'],
group_id=group.id)
student.account = user
student.add_to_db()
db.session.commit()
return student
def get_executer_data(query, recursive=False, include_unattached=False):
from app.models import Project, Datacenter, Group, Host
host_fields = list(Host.FIELDS)
group_fields = list(Group.FIELDS)
if recursive:
host_fields += ["all_tags", "all_custom_fields"]
group_fields += ["all_tags", "all_custom_fields"]
projects = Project.find(query)
projects = cursor_to_list(projects)
project_ids = [x["_id"] for x in projects]
groups = Group.find({"project_id": {"$in": project_ids}})
groups = cursor_to_list(groups, fields=group_fields)
group_ids = [x["_id"] for x in groups]
if include_unattached:
hosts = Host.find({})
else:
hosts = Host.find({"group_id": {"$in": group_ids}})
hosts = cursor_to_list(hosts, fields=host_fields)
datacenters = Datacenter.find({})
datacenters = cursor_to_list(datacenters)
return {
"datacenters": datacenters,
"projects": projects,
"groups": groups,
"hosts": hosts
}
def create_group(user_id):
print(f"{user_id} making post request to /group")
post_data = request.get_json()
group_name = post_data['group_name']
print(group_name)
#TODO: there is no need for group to have unique name
group = Group.query.filter_by(name=group_name).first()
if group:
return make_response(
jsonify({
"success": False,
"message": "group already exists. Try a different name"
})), 409
# TODO: add the member in a transaction
group = Group(name=group_name)
db.session.add(group)
db.session.commit()
group = group.query.filter_by(name=group_name).first()
member = Member(user_id, group.id, False)
db.session.add(member)
db.session.commit()
return make_response(
jsonify({
"success": True,
"message": "group created successfully"
})), 200
def index(page=1):
"""
主页显示组别
"""
if request.method == 'POST':
# 获取前端请求数据
if not request.json or not 'group_id' in request.json:
return jsonify({'code': 0, 'message': 'Missing Parameters'})
group_id = request.get_json().get('group_id')
try:
articles = Article.query.filter_by(group_id=group_id, is_delete=0)
urls = [Article.to_dict(article) for article in articles]
if len(urls) < 1:
return jsonify({'code': 0, 'message': 'Data Not Found'})
return jsonify({'code': 1, 'urls': urls, 'message': 'Success'})
except:
return jsonify({'code': 0, 'message': 'Database query failed'})
else:
# 显示所有组别以及默认返回第一组的文章链接
current_page = request.args.get('current_page', page)
g_count = Config.GROUPCOUNT
group_count = request.args.get('group_count', g_count) # 默认一页显示10组
try:
pagination = Group.query.filter_by(is_delete=0).paginate(current_page, group_count, error_out=False)
groups = pagination.items
groups = [Group.to_dict(group) for group in groups]
count = Group.query.filter_by(is_delete=0).count()
group_id = (page - 1) * g_count + 1 # 比如点击第一页的时候默认显示第一组的文章链接，点击第二页的时候默认显示第十一组的文章链接
articles = Article.query.filter_by(group_id=group_id, is_delete=0)
urls = [Article.to_dict(article) for article in articles]
if len(urls) < 1:
urls = 'Data Not Found'
return jsonify({'code': 1, 'groups': groups, 'count': count, 'urls': urls, 'message': 'Success'})
except:
return jsonify({'code': 0, 'message': 'Database query failed'})
def register():
# if current_user.is_authenticated:
# return redirect(url_for('group', groupname=session['groupname']))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data.lower(),
email=form.email.data,
usertype=form.usertype.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
# auto-generate group when a new elderly user registered
if form.usertype.data == "elderly":
group = Group(groupname="Group-" + form.username.data.lower(),
elder=form.username.data,
admin=form.username.data)
db.session.add(group)
# let the registered elderly join his own gorup
myuser = User.query.filter(
User.username == form.username.data).first()
mygroup = Group.query.filter(
Group.admin == form.username.data).first()
myuser.join_group(mygroup)
db.session.commit()
flash('Welcome new user, please login now!', 'success')
return redirect(url_for('auth.login'))
return render_template('register.html', title='Register', form=form)
def create_groups():
req = request.get_json()
g_name = req['groupname']
has = Group.query.filter_by(group_name=g_name).first()
if has:
return jsonify({'status': 400})
group = Group(group_name=g_name, manager_id=current_user.id)
db.session.add(group)
db.session.commit()
g_id = Group.query.filter_by(group_name=g_name).first()
datas = req['data']
for data in datas:
vh = GroupValidHeaders(group_id=g_id.id,
header_name=data['header'],
data_type=data['type'])
db.session.add(vh)
db.session.commit()
db.engine.execute(
text(
f"UPDATE `user` SET group_id = {g_id.id} where id={current_user.id}"
))
return jsonify({'status': 200})
def group_create():
"""Create new group based on post request from network page modal."""
form = GroupCreateForm()
code = 200
if current_user.email_verified and request.method == 'POST':
if form.validate():
group = Group.create(
name=form.name.data, description=form.description.data,
admin_id=current_user.id
)
current_user.add(group)
flash(
f"Successfully created {group.name} and added you as member."
)
return redirect(url_for('relationship.network_groups'))
else:
flash(
"Group creation failed. Please correct errors and resubmit."
)
code = 422
elif not current_user.email_verified:
disableForm(form)
flash("Create new group disabled. Please verify email to unlock.")
return render_template("relationship/groupcreate.html", form=form,
title="Create Group"), code
def download_files(msg):
'''下载一些文件'''
group_dict = Group.name_id_dict()
group = msg.User.NickName
group_id = group_dict.get(group, 'group_name')
data = {
'id': msg.NewMsgId,
'type': msg.Type,
'create_time': float(msg.CreateTime),
'group': group,
'group_id': group_id,
'user_actual_name': msg.ActualNickName,
}
file_type = msg.type
file_path = os.path.join(basedir, 'data', group, file_type)
if not os.path.exists(file_path):
os.makedirs(file_path)
fileName = os.path.join(file_path, msg.fileName)
msg.download(fileName)
data['content'] = fileName
group_msg = GroupMsg.create(data)
msg['Text'] = '下载方法'
log(zh_str(msg), 'file.txt')
log(zh_str(group_msg.to_dict()), 'down_load.txt')
print '@%s@%s' % (msg.type, msg.fileName)
def createGroup(request):
userid = request.user.username
user = Users.objects.get(user_id = userid)
if request.method == "POST":
name = request.POST.get('name', '')
description = request.POST.get('description', '')
creator = request.user.username
if name != "" and description != "":
newGroup = Group(group_name = name, group_description=description,creator=creator,
member_2="None", member_3="None")
newGroup.save()
user.group = name
user.save()
return HttpResponseRedirect('/createGroup_success')
else:
return HttpResponseRedirect('/createGroup_invalid')
return render(request, 'CreateGroup.html', {})
def groupAdd(request):
"""
add group
"""
if request.method=="POST":
myDict = dict(request.POST.iterlists())
if(not myDict.get('AddGroup')):
return
name=myDict['EditGroupName'][0].strip()
if(name==''):
messages.error(request, '组名不能为空')
return
if(Group.objects.filter(name=name).count()!=0):
messages.error(request, '组名已存在')
return
mG=Group(name=name)
if(myDict.get('EditGroupMember')):
leaderID=myDict['EditLeaderID'][0]
leader=Staff.objects.get(id=leaderID)
mG.leader=leader
mG.save()
selectMem=myDict.get('EditGroupMember')
for mem in selectMem:
staff=Staff.objects.get(id=mem)
mG.member.add(staff)
mG.save()
cache.clear()
messages.success(request, '添加成功')
def validate(self):
if not Form.validate(self):
return False
if self.name.data == self.original_name:
return True
if self.name.data != Group.make_valid_name(self.name.data):
self.name.errors.append(gettext('This name has invalid characters. Please use letters, numbers, dots and underscores only.'))
return False
org = Organization.query.filter_by(name = self.org_name).first()
if org == None:
self.name.errors.append(gettext('The organization name was not found'))
return False
env = org.envs.filter_by(name = self.env_name).first()
if env == None:
self.name.errors.append(gettext('The environment name was not found'))
return False
grp = env.groups.filter_by(name = self.name.data).first()
if grp != None:
self.name.errors.append(gettext('The group name already exists'))
return False
return True
def edit(group_id):
if not (ModuleAPI.can_write("group")):
return abort(403)
group = Group.by_id(group_id)
form = EditGroup(request.form, group)
if request.method == "POST":
form = EditGroup(request.form)
if form.validate_on_submit():
name = form.data["name"].strip()
maillist = form.data["maillist"].strip().lower()
valid_form = True
group_with_same_name = Group.query.filter(Group.name == name, Group.id != group_id).first()
if group_with_same_name is not None:
flash("The naam van de groep wordt al gebruikt", "danger")
valid_form = False
if valid_form:
group.name = name
group.maillist = maillist
if maillist == "":
group.maillist = None
else:
group.maillist = maillist
db.session.commit()
google.create_group_if_not_exists(name, maillist)
group.add_members_to_maillist()
flash("De groep is aangepast.", "success")
return redirect(url_for("group.view"))
return render_template("group/create.htm", title="Pas groep aan", form=form, group=group)
from app import db
from app.models import Group, Contact
import random
from datetime import datetime
import sys
def get_random_name(names_list, size = 1):
name_lst = [names_list[random.randrange(0,len(names_list))].capitalize() for i in range(0, size)]
return " ".join(name_lst)
g1 = Group()
g1.name = 'Friends'
g2 = Group()
g2.name = 'Family'
g3 = Group()
g3.name = 'Work'
try:
db.session.add(g1)
db.session.add(g2)
db.session.add(g3)
db.session.commit()
except:
db.session.rollback()
f = open('NAMES.DIC', "rb")
names_list = [x.strip() for x in f.readlines()]
f.close()
from app import db
from app.models import Group, Gender, Contact
import random
from datetime import datetime
import sys
def get_random_name(names_list, size = 1):
name_lst = [names_list[random.randrange(0,len(names_list))].capitalize() for i in range(0, size)]
return " ".join(name_lst)
g1 = Group()
g1.name = 'Friends'
g2 = Group()
g2.name = 'Family'
g3 = Group()
g3.name = 'Work'
try:
db.session.add(g1)
db.session.add(g2)
db.session.add(g3)
db.session.commit()
except:
db.session.rollback()
g1 = Gender()
g1.name = 'Male'
g2 = Gender()
g2.name = 'Female'
try:
db.session.add(g1)
from datetime import datetime
from app.models import Participant, Group, Event, ExpenseType, Weight, Expense
group_a = Group(name="Family A")
group_a.save()
group_b = Group(name="Family B")
group_b.save()
group_c = Group(name="Family C")
group_c.save()
event = Event(name="Holidays in Greece", start_date=datetime.now(), end_date=datetime.now())
event.save()
participant_a = Participant(
first_name ="John",
last_name = "A",
email = "*****@*****.**",
join_date = datetime.now(),
group = group_a
)
participant_a.save()
participant_a.event = [event]
participant_a.save()
participant_b = Participant(
first_name ="Jack",
last_name = "B",
email = "*****@*****.**",
join_date = datetime.now(),
group = group_b
def save_model(self, request, obj, form, change):
ldap_user_name = str(obj.ldap_user_name) if obj.ldap_user_name else None
udn = Person.ldap_udn_for( ldap_user_name )
try:
if (not ldap_user_name) or (ldap_user_name is None):
logging.warning("An LDAP user was not given. It is not updated!")
super(PersonAdmin, self).save_model(request, obj, form, change)
return
if Person.exists_in_ldap(ldap_user_name): # actualizar
ldap_person = Person.get_from_ldap(ldap_user_name)
# update data
ldap_person.update_ldap_data_from(obj)
# update password only for superuser
if str(ldap_person.ldap_user_password) != str(obj.ldap_user_password) \
and request.POST.has_key('ldap_user_password_check'):
if request.user.is_superuser:
logging.warning("User '%s' already exists in Ldap. changing password.." % ldap_user_name)
Person.update_ldap_user_password ( ldap_user_name, str(obj.ldap_user_password) )
else:
raise ValidationError( _('cant_change_password') )
# update group only for superuser
if str(ldap_person.group_id) != str(obj.group_id):
if request.user.is_superuser:
logging.warning("User '%s' already exists in Ldap. Changing group '%s' by '%s'.." % \
(ldap_user_name,ldap_person.group_id, obj.group_id ) )
Group.add_member_to(ldap_user_name, {'group_id': str(obj.group_id)})
Group.remove_member_of(ldap_user_name, ldap_person.group_id)
ldap_person.update_ldap_gidgroup( str(obj.group_id) )
else:
raise ValidationError( _('cant_change_group') )
else: # crear nuevo
new_uid_number = Person.next_ldap_uidNumber()
if not (new_uid_number > 0):
logging.error( "The following 'ldap user uid' could not be determined. " \
"The value obtained was %s" % str(new_uid_number))
raise ValidationError( _('without_ldap_user_uid') )
if Person.exist_ldap_uidNumber(new_uid_number):
logging.error("The ldap user uidNumber '%s' already exist!." % str(new_uid_number))
new_uid_number = 0
raise ValidationError( _('uidnumber_already_exist') % {'uidnumber':str(new_uid_number)} )
# Create new ldapp user
cnuser = LdapConn.parseattr( "%s %s" % (obj.name, obj.surname) )
snuser = LdapConn.parseattr( "%s" % obj.surname )
new_user = [
('objectclass', settings.LDAP_PEOPLE_OBJECTCLASSES),
('cn', [cnuser]),
('sn', [snuser]),
('givenName', [ LdapConn.parseattr(obj.name)] ),
('paisdoc', [settings.LDAP_PEOPLE_PAISDOC] ),
('tipodoc', [str(obj.document_type)] ),
('numdoc', [str(obj.document_number)] ),
('uidNumber', [str(new_uid_number)] ),
('userPassword', [str(obj.ldap_user_password)] ),
('homedirectory', [str('%s%s' % ( settings.LDAP_PEOPLE_HOMEDIRECTORY_PREFIX,
ldap_user_name))]),
('gidNumber', [str(obj.group_id)] ),
('loginShell', [str(settings.LDAP_PEOPLE_LOGIN_SHELL)]),]
if obj.position:
new_user.append(('employeeType', [str(obj.position)] ))
if obj.area:
new_user.append(('destinationIndicator', [str(obj.area)]))
if obj.floor:
new_user.append(('departmentNumber', [str(obj.floor)] ))
if obj.work_phone:
new_user.append(('telephoneNumber', [str(obj.work_phone)]))
if obj.home_phone:
new_user.append(('homePhone', [str(obj.home_phone)]))
if obj.office_name():
new_user.append(('physicalDeliveryOfficeName',
[str(LdapConn.parseattr(obj.office_name()))]))
if obj.email:
mails = []
mails.append(str(obj.email))
if obj.alternative_email:
mails.append(str(obj.alternative_email))
new_user.append(('mail',mails))
Person.create_ldap_user( ldap_user_name, new_user )
# Update ldap groups
cn_group = Group.cn_group_by_gid(obj.group_id)
cn_groups = ['%s' % str(cn_group)]
if settings.LDAP_DEFAULT_GROUPS:
cn_groups += settings.LDAP_DEFAULT_GROUPS
Group.add_member_in_groups( ldap_user_name, cn_groups )
obj.save()
except ValidationError as e:
messages.set_level(request, messages.ERROR)
messages.error(request,"%s" % e[0])
