public Organisation CreateOrganisation(CreateOrganisation dto)
{
var org = new Organisation()
{
Name = dto.Name,
TelNumber = dto.TelNumber,
AddressLine1 = dto.AddressLine1,
AddressLine2 = dto.AddressLine2,
Town = dto.Town,
County = dto.County,
Postcode = dto.Postcode,
DefaultLanguageId = dto.DefaultLanguageId,
DefaultCalendarId = dto.DefaultCalendarId,
IsActive = true
};
var rootUser = new OrgUser()
{
Organisation = org,
IsRootUser = true,
IsWebUser = true,
IsMobileUser = false,
UserName = dto.RootUserEmail,
Email = dto.RootUserEmail,
FirstName = dto.RootUserFirstName,
Surname = dto.RootUserSurname,
TypeId = OrgUserTypesRepository.Administrator.Id,
AccountType = AccountType.WebAccount
};
CurrentUOW.OrganisationRepository.InsertOrUpdate(org);
using (var tran = CurrentUOW.Context.Database.BeginTransaction())
{
CurrentUOW.Save();
var identityResult = CurrentUOW.UserManager.CreateSync(rootUser, dto.RootPassword);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.ToString(". "));
}
foreach (var role in OrgUserTypesRepository.Administrator.GetRoles())
{
identityResult = CurrentUOW.UserManager.AddToRoleSync(rootUser.Id, role);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.ToString(". "));
}
}
org.RootUser = rootUser;
CurrentUOW.Save();
// if user manager created the application user successfully
tran.Commit();
}
return(org);
}
public FormTemplate Clone(FormTemplate template, OrgUser user, string newTitle, string newColour, Guid?newProjectId)
{
var clone = template.Clone();
clone.Title = newTitle;
clone.Colour = newColour;
clone.ProjectId = newProjectId;
clone.CreatedById = user.Id;
clone.IsPublished = true;
using (var tran = Context.Database.BeginTransaction())
{
InsertOrUpdate(clone);
Save();
if (template.CalendarDateMetricId != null)
{
clone.CalendarDateMetricId = clone.MetricGroups.SelectMany(g => g.Metrics)
.Single(m => m.ShortTitle == template.CalendarDateMetric.ShortTitle).Id;
}
if (template.TimelineBarMetricId != null)
{
clone.TimelineBarMetricId = clone.MetricGroups.SelectMany(g => g.Metrics)
.Single(m => m.ShortTitle == template.TimelineBarMetric.ShortTitle).Id;
}
InsertOrUpdate(clone);
Save();
tran.Commit();
}
return(clone);
}
public ActionResult Contact(ContactViewModel model)
{
if (!ModelState.IsValid)
{
ViewBag.ErrorMessage = string
.Join("</br>", ModelState.Values.Where(E => E.Errors.Count > 0).SelectMany(E => E.Errors).Select(E => $"{E.ErrorMessage}").ToArray());
return(View(model));
}
OrgUser mayor = Mapper.Map <OrgUser, OrgUser>(DataProvider.GetUserByUserName("Mayor"));
EmailMessage <ContactViewModel> message = new EmailMessage <ContactViewModel>(model.SenderEmail, mayor.Email)
{
Subject = String.Format("{0}{1}", Resources.GetAppResourcesValue(OrganizationPortal.Resources.AppResourcesKeys.AppName), model.Subject != null ? " | " + model.Subject : ""),
Model = model
};
try
{
SendEmail <ContactViewModel>(message, "SendEmailToMayor");
}
catch (Exception ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View(model));
}
ViewBag.SuccessMessage = "Имейлът беше изпратен успешно !";
ModelState.Clear();
return(View(new ContactViewModel()));
}
private void button2_Click(object sender, EventArgs e)
{
// add org user
string strParmaInfo = "";
GlareLedServices2.GLSysMgrSoapClient cl = new GlareLedServices2.GLSysMgrSoapClient();
OrgUser userMod = new OrgUser()
{
Id = 0,
MgrOrgId = 1,
Name = "orgname",
Password = "******"
};
string strInfo = JsonStrObjConver.Obj2JsonStr(userMod, typeof(OrgUser));
RequestModelString obj2 = new RequestModelString()
{
Info = strInfo,
reqDt = DateTime.Now,
TockId = ConstDefineTestWebapi.TockIdEnableTest
};
strParmaInfo = JsonStrObjConver.Obj2JsonStr(obj2, typeof(RequestModelString));
string strResult = cl.AddOrgUser(strParmaInfo);
MessageBox.Show(strResult);
}
public void CloseLastSubscription(OrgUser user)
{
// cancel last subscription, if any.
var lastSubscription = UnitOfWork.SubscriptionsRepository.AllAsNoTracking
.Where(x => x.OrgUserId == user.Id && x.IsActive)
.OrderByDescending(x => x.DateCreated)
.FirstOrDefault();
if (lastSubscription != null)
{
if (lastSubscription.Type == UserSubscriptionType.Organisation)
{
lastSubscription.EndDate = DateTimeService.UtcNow;
lastSubscription.IsActive = false;
UnitOfWork.SubscriptionsRepository.InsertOrUpdate(lastSubscription);
}
else
{
var paymentRecord = UnitOfWork.PaymentsRepository.Find(lastSubscription.PaymentRecord.Id);
foreach (var record in paymentRecord.Subscriptions)
{
record.IsActive = false;
}
UnitOfWork.PaymentsRepository.InsertOrUpdate(paymentRecord);
}
}
}
public ActionResult DeleteUsers(int id, int orgId)
{
OrgUser entity = _repOrgUser.Find(id);
_repOrgUser.Delete(entity);
return(RedirectToAction("Detail", new { id = orgId }));
}
public static bool AddUser(ref OrgUser model, out string strErrorMsg)
{
strErrorMsg = "";
if (IsUserNameExist(model.Name))
{
strErrorMsg = ConstDefineBll.NameExist;
return(false);
}
using (GLedDbEntities ent = new GLedDbEntities())
{
OrgUser newinfo = new OrgUser()
{
Id = model.Id,
MgrOrgId = model.MgrOrgId,
Name = model.Name,
Password = model.Password,
CreateDt = DateTime.Now,
UpdateDt = DateTime.Now
};
ent.OrgUser.Add(newinfo);
ent.SaveChanges();
model.Id = newinfo.Id;
}
return(true);
}
public void MoveUserCaseToOrganization(OrgUser user, Organisation organisation)
{
// update user's organisation
user.OrganisationId = organisation.Id;
// update user's current project, if exists
if (user.CurrentProject != null && user.CurrentProject.CreatedById == user.Id)
{
var project = UnitOfWork.ProjectsRepository.Find(user.CurrentProject.Id);
project.OrganisationId = organisation.Id; // update project's organisation
// update threads under this project
var threads = UnitOfWork.FormTemplatesRepository
.AllAsNoTracking
.Where(t => t.ProjectId == project.Id)
.ToList();
// update form templates' organisation
foreach (var form in threads)
{
form.OrganisationId = organisation.Id;
UnitOfWork.FormTemplatesRepository.InsertOrUpdate(form);
}
}
}
private void NotifyOrgAdminAboutApprovedRequest(Organisation organisation, OrgUser orgUser)
{
if (organisation.RootUserId.HasValue)
{
var orgAdmin = UnitOfWork.OrgUsersRepository
.AllAsNoTracking
.Where(x => x.Id == organisation.RootUserId.Value)
.SingleOrDefault();
var rootIndex = WebHelpers.GetRootIndexPath();
var url = $"{Request.RequestUri.Scheme}://{Request.RequestUri.Authority}/{rootIndex}#!/users/mobile/";
var emailBody = @"<p>A new user has joined your organisation: <strong>" + orgUser.UserName + @"</strong>.</p>
<p>The user's personal case is now filed under your organisation and you have access to it.</p>
<p>You can remove this user whenever you like, and put them back under OnRecord.</p>
<p><br></p>
<p>View the <a href='" + url + @"'>directory of mobile users</a> on the dashboard.</p>";
var orgAdminEmail = new Email
{
To = orgAdmin.Email,
Subject = $"User joined organization - {orgUser.UserName}",
Content = WebHelpers.GenerateEmailTemplate(emailBody, "A user has joined your organization")
};
UnitOfWork.EmailsRepository.InsertOrUpdate(orgAdminEmail);
}
}
public void UnassignRootUserFromProject(OrgUser user, Organisation organisation, Organisation OnRecord)
{
if (user.CurrentProject != null && user.CurrentProject.CreatedById == user.Id)
{
// remove org root admin from this project
var rootUserAssignment = UnitOfWork.AssignmentsRepository
.AllAsNoTracking
.Where(x => x.OrgUserId == organisation.RootUserId && x.ProjectId == user.CurrentProject.Id)
.FirstOrDefault();
UnitOfWork.AssignmentsRepository.Delete(rootUserAssignment);
// assign project to OnRecord admin again
if (OnRecord.RootUser != null)
{
var OnRecordRootAssignment = UnitOfWork.AssignmentsRepository
.AllAsNoTracking
.Where(x => x.OrgUserId == OnRecord.RootUserId && x.ProjectId == user.CurrentProject.Id)
.FirstOrDefault();
if (OnRecordRootAssignment == null)
{
AssignRootUserToProject(user.CurrentProject.Id, OnRecord.RootUser.Id);
}
}
}
}
public string AddOrgUser(string strParams)
{
string strError;
RequestModelString reqinfo = ServerHlper.GetRequestModelString(System.Reflection.MethodBase.GetCurrentMethod().Name,
strParams, out strError);
if (reqinfo == null)
{
return(strError);
}
if (!LoginBll.CheckLoginId(reqinfo.TockId))
{
return(ServerHlper.MakeInfoByStatus(false, ConstDefineWs.LoginInfoError));
}
OrgUser mod = JsonStrObjConver.JsonStr2Obj(reqinfo.Info, typeof(OrgUser)) as OrgUser;
if (mod == null)
{
return(ServerHlper.MakeInfoByStatus(false, "需要添加的用户参数不对"));
}
if (OrgUserBll.IsUserNameExist(mod.Name))
{
return(ServerHlper.MakeInfoByStatus(false, "需要添加的用户名已经存在"));
}
bool result = OrgUserBll.AddUser(ref mod, out strError);
return(ServerHlper.MakeInfoByStatus(result, strError));
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var info = await Authentication.GetExternalLoginInfoAsync();
if (info == null)
{
return(InternalServerError());
}
var user = new OrgUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await UserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public List <FilledFormDTO> GetUserSurveys(OrgUser orgUser, FormTemplateDiscriminators discriminator, Guid?projectId = null)
{
var result = new List <FilledFormDTO>();
var surveys = UnitOfWork.FilledFormsRepository
.AllAsNoTracking
.Where(x => x.FormTemplate.Discriminator == discriminator);
if (projectId.HasValue && projectId != Guid.Empty)
{
if (orgUser.Type != OrgUserTypesRepository.Administrator)
{
var threadAssignments = UnitOfWork.ThreadAssignmentsRepository
.AllAsNoTracking
.Where(x => x.OrgUserId == orgUser.Id)
.ToList();
var projectFound = threadAssignments.Any(x => x.FormTemplate.ProjectId == projectId);
var assignment = orgUser.Assignments.SingleOrDefault(a => a.ProjectId == projectId);
if (!projectFound)
{
if (assignment == null || !assignment.CanView)
{
return(null);
}
}
}
surveys = surveys.Where(s => s.ProjectId == projectId);
result = surveys
.ToList()
.OrderByDescending(x => x.Date)
.Select(s => Mapper.Map <FilledFormDTO>(s))
.ToList();
}
else
{
// return all projects that this user has a case or thread assignment for.
var caseSurveys = surveys.Where(s => s.Project.Assignments.Any(a => a.OrgUserId == orgUser.Id && a.CanView));
var threadSurveys = surveys.Where(s => s.FormTemplate.Assignments.Any(a => a.OrgUserId == orgUser.Id && a.CanView));
var joinedSurveys = new List <FilledForm>();
joinedSurveys.AddRange(caseSurveys.ToList());
joinedSurveys.AddRange(threadSurveys.ToList());
joinedSurveys = joinedSurveys.Distinct().ToList();
result = joinedSurveys
.ToList()
.OrderByDescending(x => x.Date)
.Select(s => Mapper.Map <FilledFormDTO>(s))
.ToList()
.Distinct()
.ToList();
}
return(result);
}
private IEnumerable <Claim> GetUserRoleClaims(OrgUser user)
{
List <Claim> claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id));
//claims.Add(new Claim(ClaimTypes.Role, user.UserPermissionType));
return(claims);
}
public void SubscribeUserToOnRecord(OrgUser user)
{
var OnRecord = UnitOfWork.OrganisationRepository.AllAsNoTracking
.Where(x => x.Name == "OnRecord")
.SingleOrDefault();
SubscribeUserToOrganization(user, OnRecord);
}
public SurveyProvider(OrgUser user, UnitOfWork uow, bool onlyPublished = true)
{
this.User = user;
this.UOW = uow;
this.OnlyPublished = onlyPublished;
this.UserTypesWithFullAccess = new List <OrgUserType>(new[] { OrgUserTypesRepository.Administrator, OrgUserTypesRepository.Manager });
this.UserTypesWithLimitedAccess = new List <OrgUserType>(new[] { OrgUserTypesRepository.TeamUser, OrgUserTypesRepository.ExternalUser });
}
public ActionResult DeleteConfirmed(Guid id)
{
OrgUser orgUser = db.OrgUsers.Find(id);
db.OrgUsers.Remove(orgUser);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult AddMember(int orgId, int selectedUserId)
{
OrgUser entitiy = new OrgUser();
entitiy.OrgId = orgId;
entitiy.UserId = selectedUserId;
_repOrgUser.Insert(entitiy);
return(RedirectToAction("Detail", new { id = orgId }));
}
private IEnumerable <Claim> GetUserClaims(OrgUser user)
{
List <Claim> claims = new List <Claim>();
claims.Add(new Claim(ClaimTypes.NameIdentifier, user.Id));
claims.Add(new Claim(ClaimTypes.Name, user.UserName));
claims.Add(new Claim(ClaimTypes.Email, user.Email));
claims.AddRange(this.GetUserRoleClaims(user));
return(claims);
}
public ActionResult AddMember(int selectedUser, int orgId)
{
OrgUser orgUser = new OrgUser();
orgUser.OrgId = orgId;
orgUser.UserId = selectedUser;
_orgUserrepository.Add(orgUser);
return(RedirectToAction("Detail", new { id = orgId }));
}
public IActionResult Demo()
{
OrgUser org = new OrgUser();
using (var ctx = new lodsContext()) {
org = new OrgUser();
org.Organization = ctx.Organization.ToList();
org.Users = ctx.Users.ToList();
}
return(View(org));
}
public void RemoveUserFromCurrentTeams(OrgUser user)
{
// remove this user from any teams in current organisation.
var teamRecords = UnitOfWork.OrgTeamUsersRepository
.AllAsNoTracking
.Where(x => x.OrgUserId == user.Id && x.OrganisationTeam.OrganisationId == user.OrganisationId)
.ToList();
foreach (var record in teamRecords)
{
UnitOfWork.OrgTeamUsersRepository.Delete(record);
}
}
public async Task <OrgUser> GetOrgUserByUserID(int userId)
{
return(await WithConnection(async c =>
{
string sql = "SELECT * FROM org_user WHERE user_id = @UserID and is_del != 1";
OrgUser orguser = await c.QueryFirstOrDefaultAsync <OrgUser>(sql,
new
{
UserID = userId
});
return orguser;
}));
}
public ActionResult Edit([Bind(Include = "Id,OrgId,GroupId,UserId,CreatedDate,ModifiedDate,IsActive")] OrgUser orgUser)
{
if (ModelState.IsValid)
{
db.Entry(orgUser).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserId = new SelectList(db.AppUsers, "Id", "Name", orgUser.UserId);
ViewBag.GroupId = new SelectList(db.Groups, "Id", "Name", orgUser.GroupId);
ViewBag.OrgId = new SelectList(db.Orgs, "Id", "Name", orgUser.OrgId);
return(View(orgUser));
}
public void Add(OrgUser dto)
{
if (string.IsNullOrEmpty(dto.Id))
{
dto.Id = ConfigHelper.NewGuid;
}
dto.CreateTime = dto.ModifiedTime = DateTime.Now;
using (var dataContext = DataContext)
{
dataContext.OrgUsers.InsertOnSubmit(dto);
dataContext.SubmitChanges();
}
}
public async Task <InvokeResult> AddUserToOrgAsync(string orgId, string userId, EntityHeader userOrg, EntityHeader addedBy)
{
await AuthorizeOrgAccessAsync(addedBy, userOrg, typeof(OrgUser), Actions.Create, new SecurityHelper()
{
OrgId = orgId, UserId = userId
});
var appUser = await _appUserRepo.FindByIdAsync(userId);
if (appUser == null)
{
return(InvokeResult.FromError($"Could not find user with user id [{userId}] when attempting to add user to the org [{orgId}]"));
}
var org = await _organizationRepo.GetOrganizationAsync(orgId);
if (org == null)
{
return(InvokeResult.FromError($"Could not find org with org id [{orgId}] when attempting to add a user with id [{userId}] to this org."));
}
await AuthorizeOrgAccessAsync(addedBy, org.ToEntityHeader(), typeof(OrgUser));
if (await _orgUserRepo.QueryOrgHasUserAsync(orgId, userId))
{
var result = new InvokeResult();
result.Errors.Add(new ErrorMessage(UserAdminResources.OrganizationUser_UserExists.Replace(Tokens.USERS_FULL_NAME, appUser.Name).Replace(Tokens.ORG_NAME, org.Name)));
return(result);
}
var user = new OrgUser(org.Id, userId)
{
Email = appUser.Email,
OrganizationName = org.Name,
IsOrgAdmin = false,
IsAppBuilder = false,
UserName = appUser.Name,
ProfileImageUrl = appUser.ProfileImageUrl.ImageUrl,
};
user.CreatedBy = addedBy.Text;
user.CreatedById = addedBy.Text;
user.CreationDate = DateTime.UtcNow.ToJSONString();
user.LastUpdatedBy = addedBy.Text;
user.LastUpdatedById = addedBy.Id;
user.LastUpdatedDate = user.CreationDate;
await _orgUserRepo.AddOrgUserAsync(user);
return(InvokeResult.Success);
}
private async Task <OrgTree> _findTopNode(int userid)
{
OrgUser orguser = await _orgRepo.GetOrgUserByUserID(userid);
OrgTree topNode = null;
if (orguser != null)
{
List <OrgTree> nodes_all = await _orgRepo.ListAllOrgNode();
topNode = _findTopNode(orguser.NodeID, nodes_all);
}
return(topNode);
}
public static bool Validate(this OrgUser orgUser)
{
if (orgUser.UserId < 1)
{
throw new AppException("The provided org user lacks a user", ExceptionType.Validation);
}
if (orgUser.OrgId < 1)
{
throw new AppException("The provided org user lacks an org", ExceptionType.Validation);
}
return(true);
}
// GET: OrgUsers/Details/5
public ActionResult Details(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OrgUser orgUser = db.OrgUsers.Find(id);
if (orgUser == null)
{
return(HttpNotFound());
}
return(View(orgUser));
}
public async Task <IActionResult> RescindAdminRights([FromRoute] int npoId, string userId)
{
OrgUser userFromTokenIsInOrg = await _orgUserRepo.GetUserInOrgByOrgIdAndUserId(npoId, GetUserIdFromToken());
if (userFromTokenIsInOrg == null)
{
return(Unauthorized(new { Status = StatusCode(401) }));
}
if (!userFromTokenIsInOrg.IsActive && !userFromTokenIsInOrg.IsAdminOfOrg)
{
return(Unauthorized(new { Status = StatusCode(401) }));
}
var user = await _userRepo.GetUserById(userId);
if (user == null)
{
return(BadRequest(new { Status = false, Message = "User not found" }));
}
var org = await _npoRepo.GetNPOById(npoId);
if (org == null)
{
return(BadRequest(new { Status = false, Message = "NPO not found" }));
}
var countOfAdmins = await _orgUserRepo.GetCountOfAdminsForOrg(npoId);
if (countOfAdmins <= 1)
{
return(BadRequest(new { Status = StatusCode(400), Message = "Must have a minimum of one admin" }));
}
try
{
var userIsNoLongerAdmin = await _orgUserRepo.RescindAdminPrivledgesOfUserAsync(npoId, userId);
if (userIsNoLongerAdmin)
{
return(Ok(new { Status = StatusCode(204) }));
}
return(BadRequest(new { Status = StatusCode(400), Message = "Removing admin rights to the user failed." }));
}
catch (Exception)
{
throw;
}
}
