public void CreateMember(CreateMemberModel model)
{
try
{
Members memberCreate = new Members
{
email = model.email,
password = PasswordHashModel.Hash(model.password),
firstname = model.password,
lastname = model.lastname,
position = model.position,
role = model.role,
created = DateTime.Now,
updated = DateTime.Now
};
this.onConvertBase64ToImage(memberCreate, model.image);
this.db.Members.Add(memberCreate);
this.db.SaveChanges();
}
catch (Exception ex)
{
throw ex.GetErrorException();
}
}
private MemberModel GetMember(CreateMemberModel createMemberModel)
{
return(new MemberModel
{
Email = createMemberModel.Email
});
}
public async Task <int> CreateMember(CreateMemberModel createMemberModel)
{
if (createMemberModel != null)
{
return(await _memberRepository.SaveMember(createMemberModel).ConfigureAwait(false));
}
return(-1);
}
public void InsertUser(CreateMemberModel memberModel)
{
var connection = new MySqlConnection(DbConnectionString);
connection.Execute(
"INSERT INTO member (first_name, last_name) VALUES (@FirstName, @LastName)",
new { FirstName = memberModel.FirstName, LastName = memberModel.LastName }
);
}
public ActionResult Add(CreateMemberModel model)
{
MembershipCreateStatus status;
_membershipService.CreateUser(model.UserName, model.Password, model.Email, null, null, true, null, out status);
_roleService.AddUsersToRoles(new[] { model.UserName }, new[] { "Administrator" });
return(RedirectToAction("Index"));
}
public IActionResult CreateMember([FromForm] CreateMemberModel memberModel)
{
if (!ModelState.IsValid)
{
return(View("CreateMember"));
}
_membersService.InsertUser(memberModel);
return(Redirect(Url.Action("GetAllMembers")));
}
public Member CreateMember(CreateMemberModel createMemberModel)
{
return(new Member
{
Email = createMemberModel.Email,
FirstName = createMemberModel.FirstName,
LastName = createMemberModel.LastName,
Role = createMemberModel.Role
});
}
public async Task <ActionResult <MemberModel> > CreateEdit([FromBody] CreateMemberModel model)
{
var operationResult = await _memberModule.CreateAndEdit(model);
if (operationResult.Result != OperationResult.Ok)
{
return(BadRequest(operationResult));
}
return(Ok(operationResult));
}
public async Task <IActionResult> CreateMember(CreateMemberModel model)
{
bool checkEmailDomain = _identityService.ValidateEmailDomain(model.Email);
if (!checkEmailDomain)
{
return(Unauthorized(AppResult.InvalidEmailDomain()));
}
var entity = await _identityService.GetUserByEmailAsync(model.Email);
if (entity != null)
{
var validationData = new ValidationData();
validationData = validationData.Fail(code: AppResultCode.EmailExisted);
return(BadRequest(AppResult.FailValidation(validationData)));
}
var emailInfo = model.Email.GetEmailInfo();
entity = _identityService.ConvertToUser(model, emailInfo.Item3);
using (var transaction = context.Database.BeginTransaction())
{
model.Roles = model.Roles ?? new HashSet <string>();
if (model.CreateDepartmentMembers.Any(o => o.IsManager == true) ||
model.CreateAreaMembers.Any(o => o.IsManager == true))
{
model.Roles.Add(RoleName.MANAGER);
}
var result = await _identityService
.CreateUserWithoutPassAsync(entity, model.Roles);
if (!result.Succeeded)
{
foreach (var err in result.Errors)
{
ModelState.AddModelError(err.Code, err.Description);
}
var builder = ResultHelper.MakeInvalidAccountRegistrationResults(ModelState);
return(BadRequest(builder));
}
_logger.CustomProperties(entity).Info("Register new user");
var memberEntity = _service.CreateMember(model, entity, emailInfo);
//log event
var ev = _sysService.GetEventForNewUser(
$"Admin has created a user with email {model.Email}",
UserId);
_sysService.CreateAppEvent(ev);
//end log event
context.SaveChanges();
transaction.Commit();
}
return(NoContent());
}
public async Task <MemberViewModel> CreateMember([FromBody] CreateMemberModel model)
{
Tk.AssertValidIds(model.GroupId, model.ContactId);
var userId = _httpContextAccessor.GetContactId();
model.CreatedBy = userId;
_logger.LogInformation($"create.groupMember Group: {model.GroupId} Contact: {model.ContactId}");
var toSave = _mapper.Map <Member>(model);
var data = await _repository.CreateAsync(toSave);
_logger.LogInformation($"created.groupMember ${data.Id}");
return(_mapper.Map <MemberViewModel>(data));
}
public AppUser ConvertToUser(CreateMemberModel model, string code)
{
var entity = new AppUser
{
Id = model.Email.Replace('@', '_'),
UserName = model.Email,
Email = model.Email,
MemberCode = code,
FullName = model.FullName,
LoggedIn = false
};
return(entity);
}
public async Task <IHttpActionResult> CreateMember([FromBody] CreateMemberModel createMemberModel)
{
if (ModelState.IsValid)
{
var memberId = await _memberService.CreateMember(createMemberModel).ConfigureAwait(false);
if (memberId != -1)
{
return(Created("", $"{Request.RequestUri.AbsoluteUri}/{memberId}"));
}
return(BadRequest("Something went wrong !"));
}
return(BadRequest("Something went wrong !"));
}
public IHttpActionResult PostCreateMember([FromBody] CreateMemberModel model)
{
if (ModelState.IsValid)
{
try
{
this.memberService.CreateMember(model);
return(Ok("Create successful"));
}
catch (Exception ex)
{
ModelState.AddModelError("Exception", ex.Message);
}
}
return(BadRequest(ModelState.GetErrorModelState()));
}
public IHttpActionResult PostCreateMember([FromBody] CreateMemberModel value)
{
if (ModelState.IsValid)
{
try
{
this._member.createdMember(value);
return(Ok("Created"));
}
catch (Exception e)
{
ModelState.AddModelError("Exception", e.Message);
}
}
return(BadRequest(ModelState.GetErrorModelState()));
}
public JsonResult SignUp(CreateMemberModel model, int nodeId)
{
ApplyFormResponse resultMessage = new ApplyFormResponse();
if (!ModelState.IsValid)
{
resultMessage.ErrorMessage = "Der er desværre sket en fejl - prøv igen";
return(Json(resultMessage));
}
var memberService = Services.MemberService;
if (memberService.GetByEmail(model.Email) != null)
{
resultMessage.ErrorCode = "Member already exists";
return(Json(resultMessage));
}
var member = memberService.CreateMemberWithIdentity(model.Username, model.Email, model.Name, "Member");
memberService.Save(member);
memberService.AssignRole(member.Id, model.SelectedGroup);
memberService.SavePassword(member, model.Password);
resultMessage.ErrorCode = "OK";
return(Json(resultMessage));
}
public void createdMember(CreateMemberModel model)
{
try
{
Member member = new Member
{
email = model.email,
password = PasswordHash.HashEncode(model.password),
firstname = model.firstname,
lastname = model.lastname,
position = model.position,
role = model.role,
updated = DateTime.UtcNow,
created = DateTime.UtcNow
};
this.convertImageBase64ToImage(member, model.image);
this._db.Members.Add(member);
this._db.SaveChanges();
}
catch (Exception e)
{
throw e.GetExceptionError();
}
}
public async Task <int> SaveMember(CreateMemberModel newMember)
{
var member = _modelFactory.CreateMember(newMember);
return(await _memberDao.SaveMember(member).ConfigureAwait(false));
}
public async Task <ResultModel <MemberModel> > CreateAndEdit(CreateMemberModel model, string mailListId = null)
{
var action = "edit";
try
{
using (HttpClient client = new HttpClient())
{
var parameters = new List <KeyValuePair <string, string> >();
if (!string.IsNullOrEmpty(model.MemberID))
{
parameters.Add(new KeyValuePair <string, string>("MemberID", model.MemberID));
}
if (mailListId != null && !string.IsNullOrEmpty(mailListId.Trim()))
{
parameters.Add(new KeyValuePair <string, string>("MailListID", mailListId));
}
else
{
if (!string.IsNullOrEmpty(model.MailListID))
{
parameters.Add(new KeyValuePair <string, string>("MailListID", model.MailListID));
}
}
parameters.Add(new KeyValuePair <string, string>("Email", model.Email));
if (model.CustomFields != null && model.CustomFields.Count < 3)
{
parameters.Add(new KeyValuePair <string, string>("CustomField1", model.CustomField1));
parameters.Add(new KeyValuePair <string, string>("CustomField2", model.CustomField2));
}
else
{
for (int i = 0; i < model.CustomFields.Count; i++)
{
parameters.Add(new KeyValuePair <string, string>("CustomField" + (i + 1), model.CustomFields[i]));
}
}
var formContent = new FormUrlEncodedContent(parameters);
var url = String.Format("{0}/{1}/{2}?{3}&{4}", _baseUri.GetURI(), _modulo, action,
_baseUri.GetAPIKEY(), _baseUri.GetFormat());
HttpResponseMessage response =
await client.PostAsync(url, formContent);
response.EnsureSuccessStatusCode();
string json = await response.Content.ReadAsStringAsync();
JObject rss = JObject.Parse(json);
try
{
JToken item = rss["root"]["ajaxResponse"]["member"];
MemberModel member = new MemberModel();
member = item.ToObject <MemberModel>();
return(new SuccessResultModel <MemberModel>(member));
}
catch
{
JToken item = rss["root"]["ajaxResponse"]["errors"];
return(new ErrorResultModel <MemberModel>(item.ToString()));
}
}
}
catch (Exception e)
{
return(new ErrorResultModel <MemberModel>(e.Message));
}
}
public Member CreateMember(CreateMemberModel model, AppUser userEntity, (bool, bool, string) emailInfo)
