public override void Update(UserJsonModel model)
{
if (model.Locale.HasValue)
{
Locale = CultureInfo.ReadOnly(new CultureInfo(model.Locale.Value ?? "en-US"));
}
if (model.Verified.HasValue)
{
IsVerified = model.Verified.Value;
}
if (model.Email.HasValue)
{
Email = model.Email.Value;
}
if (model.MfaEnabled.HasValue)
{
HasMfaEnabled = model.MfaEnabled.Value;
}
if (model.Flags.HasValue)
{
Flags = model.Flags.Value;
}
if (model.PremiumType.HasValue)
{
NitroType = model.PremiumType.Value;
}
base.Update(model);
}
public IActionResult ChangeRole(UserJsonModel model)
{
bool isChanged = _userService.ChangeRole(model);
string error = isChanged ? Messages.INFO_ENTITY_EDITED : Messages.ERROR_EDIT_PROBLEM;
return(Json(new ResponseJsonModel(isChanged, error: error)));
}
/// <summary>
/// Instantiates a new shared user.
/// </summary>
/// <param name="client"></param>
/// <param name="model"></param>
public CachedSharedUser(IGatewayClient client, UserJsonModel model)
: base(client, model)
{
_isBot = model.Bot.GetValueOrDefault();
Update(model);
}
public HttpResponseMessage Put([FromBody] UserJsonModel UserJson, [FromUri] int id)
{
var usuario = UserJson.add(id);
NHibernateSession.CurrentFor(NHibernateSession.DefaultFactoryKey).SaveOrUpdate(usuario);
NHibernateSession.CurrentFor(NHibernateSession.DefaultFactoryKey).Flush();
return(Request.CreateResponse(HttpStatusCode.OK));
}
/// <summary>
/// Instantiates a new shared user.
/// </summary>
/// <param name="client"></param>
/// <param name="model"></param>
public CachedSharedUser(IGatewayClient client, UserJsonModel model)
: base(client, model)
{
_isBot = model.Bot.GetValueOrDefault();
_references = new SynchronizedHashSet <CachedUser>();
Update(model);
}
public async Task <IActionResult> ConfirmEmail(UserJsonModel model)
{
var user = await _userManager.FindByIdAsync(model.Id);
if (user != null)
{
await _userManager.ConfirmEmailAsync(user, model.Code);
}
return(Redirect("/"));
}
public void TestCreateUser()
{
var user = new UserJsonModel();
_userService.CreateUser(user);
var users = _context.Users.Find();
Assert.IsNotNull(users);
}
public void UpdateUser(UserJsonModel user, int id)
{
var userFromDb = GetUser(id);
userFromDb.Email = user.Email;
userFromDb.LastName = user.LastName;
userFromDb.UserPassword = user.UserPassword;
userFromDb.FirstName = user.FirstName;
_userDao.UpdateUser(userFromDb);
}
public override void Update(UserJsonModel model)
{
_name = model.Username;
_discriminator = model.Discriminator;
_avatarHash = model.Avatar;
if (model.PublicFlags.HasValue)
{
_publicFlags = model.PublicFlags.Value;
}
}
private User GetUserModel(UserJsonModel user)
{
var userToSave = new User();
userToSave.Email = user.Email;
userToSave.FirstName = user.FirstName;
userToSave.LastName = user.LastName;
userToSave.UserPassword = user.UserPassword;
return(userToSave);
}
public IHttpActionResult UpdateUser(int id, UserJsonModel user)
{
try
{
_userService.UpdateUser(user, id);
return(new ResponseMessageResult(Request.CreateResponse(HttpStatusCode.OK, "User Updated")));
}
catch (Exception e)
{
return(new ResponseMessageResult(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message)));
}
}
private async Task <string> ChangePassword(UserJsonModel model)
{
if (string.IsNullOrEmpty(model.Password))
{
model.Password = Guid.NewGuid().ToString().Split('-')[0];
}
var user = await _userManager.FindByEmailAsync(model.Email);
await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
return(model.Password);
}
public IActionResult EditInfo(UserJsonModel model)
{
bool isEdited = false;
string userId = _userManager.GetUserId(HttpContext.User);
if (model.Id == userId)
{
isEdited = _userService.EditUser(model);
}
string error = isEdited ? Messages.INFO_ENTITY_EDITED : Messages.ERROR_EDIT_PROBLEM;
return(Json(new ResponseJsonModel(isEdited, error: error)));
}
public IHttpActionResult CreateUser(UserJsonModel user)
{
try
{
_userService.CreateUser(user);
return(new ResponseMessageResult(Request.CreateResponse(HttpStatusCode.OK, "User Created")));
}
catch (Exception e)
{
new ResponseMessageResult(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
return(null);
}
public HttpResponseMessage Post([FromBody] UserJsonModel UserJson)
{
UserJsonModel dao = new UserJsonModel();
var usuario = UserJson.add();
NHibernateSession.CurrentFor(NHibernateSession.DefaultFactoryKey).SaveOrUpdate(usuario);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created);
string location = Url.Link("DefaultApi", new { controller = "User", id = usuario.Id });
response.Headers.Location = new Uri(location);
return(response);
}
public async Task <OkObjectResult> EditUser(UserJsonModel model)
{
try
{
var user = await service.Find(s => s.Id == model.Id);
user = mapper.Map(model, user);
await service.Update(user);
return(Ok(mapper.Map <User, UserJsonModel>(user)));
}
catch (Exception ex)
{
return(Ok(new UserJsonModel(ex.ToString(), false)));
}
}
public bool EditUser(UserJsonModel model)
{
var user = DbContext.Users
.SingleOrDefault(c => c.Id == model.Id);
if (user != null)
{
user.TownId = model.TownId;
user.Address = model.Address;
user.PhoneNumber = model.PhoneNumber;
DbContext.SaveChanges();
return(true);
}
return(false);
}
public void TestUpdateUser()
{
var user = new UserJsonModel();
user.Email = "*****@*****.**";
_context.Users.Add(new WebApiRestful.User {
UserId = 1
});
_userService.UpdateUser(user, 1);
var users = _context.Users.Find();
Assert.IsNotNull(users);
}
public ActionResult GetGridData(string ColumnName = "none")
{
var Users = _db.User.ToList();
var usrJsonModelList = new List <UserJsonModel>();
foreach (var usr in Users)
{
var usrJsonModel = new UserJsonModel();
usrJsonModel.country = usr.Country.CountryName;
usrJsonModel.state = usr.State.StateName;
//usrJsonModel.skills =
DateTime.TryParse(usr.DOB.ToString(), out DateTime date);
usrJsonModel.DOB = date.ToString("yyyy-MM-dd");
usrJsonModel.imagePath = _db.Image.FirstOrDefault(img => img.UserId == usr.Id).ImageName;
usrJsonModelList.Add(usrJsonModel);
}
return(Json(new { data = usrJsonModelList }, JsonRequestBehavior.AllowGet));
}
public HttpResponseMessage Get(int id)
{
var test = 0;
try
{
var dao = NHibernateSession.CurrentFor(NHibernateSession.DefaultFactoryKey)
.Query <Usuario>()
.First(x => x.Id == id);
var JsonModel = UserJsonModel.ConverterDominio(dao);
//var userAsXML = ToXml(user);
return(Request.CreateResponse(HttpStatusCode.OK, JsonModel, JsonMediaTypeFormatter.DefaultMediaType));
}
catch (KeyNotFoundException)
{
var mensagem = string.Format("O Usuario {0} não foi encontrado", id);
var error = new HttpError(mensagem);
return(Request.CreateResponse(HttpStatusCode.NotFound, error, JsonMediaTypeFormatter.DefaultMediaType));
}
}
public ActionResult GetPublicWishlists(UserInfoIDModel ureq)
{
using (var db = new WishlistContext())
{
var userProfile = db.UserProfiles.FirstOrDefault(u => u.UserId == ureq.ID);
var userName = userProfile == null ? null : userProfile.UserName;
var jsonModel = new UserJsonModel
{
UserID = ureq.ID,
UserName = userName,
Wishlists =
db.Wishlists
.Where(wl => wl.UserId == ureq.ID && wl.IsPublic)
.AsEnumerable()
.Select(wl => new WishlistFullJsonModel
{
Info = new WishlistJsonModel
{
ID = wl.WishlistId,
Title = wl.WishlistTitle,
IsPublic = wl.IsPublic
},
WishlistItems =
wl.WishlistItems
.AsEnumerable()
.Select(wli => new WishlistItemJsonModel
{
ID = wli.WishlistItemId,
Content = wli.WishlistItemContent
})
.ToArray()
})
.ToArray()
};
return(Json(jsonModel));
}
}
public async Task <IActionResult> Login(UserJsonModel model)
{
if (ModelState.IsValid)
{
var isExist = _userService.IsExists(model.Email);
if (isExist)
{
string userName = _userService.GetUserName(model.Email);
var result = await _signInManager.PasswordSignInAsync(
userName, model.Password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
return(Json(new ResponseJsonModel(true)));
}
}
return(Json(new ResponseJsonModel(false, error: Messages.ERROR_INVALID_EMAIL_OR_PASSWORD)));
}
var errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage).ToList();
return(Json(new ResponseJsonModel(false, errors: errors)));
}
public async Task <IActionResult> ForgotPassword(UserJsonModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null || !await _userManager.IsEmailConfirmedAsync(user))
{
return(Json(new ResponseJsonModel(error: Messages.ERROR_INVALID_EMAIL)));
}
model.Code = await _userManager.GeneratePasswordResetTokenAsync(user);
string newPassword = await this.ChangePassword(model);
await _emailSender.SendEmailAsync(model.Email, "New Password",
"Your new password is: " + newPassword);
return(Json(new ResponseJsonModel(error: Messages.INFO_EMAIL_SENT)));
}
return(Json(new ResponseJsonModel()));
}
public async Task <IActionResult> ResetPassword(UserJsonModel model)
{
string loggedUserId = _userManager.GetUserId(HttpContext.User);
var user = await _userManager.FindByEmailAsync(model.Email);
if (ModelState.IsValid && user != null && loggedUserId == user.Id)
{
bool isOldPasswordValid = await _userManager.CheckPasswordAsync(user, model.OldPassword);
if (!isOldPasswordValid)
{
return(Json(new ResponseJsonModel(error: Messages.ERROR_INVALID_PASSWORD)));
}
model.Code = await _userManager.GeneratePasswordResetTokenAsync(user);
await this.ChangePassword(model);
return(Json(new ResponseJsonModel(error: Messages.INFO_PASSWORD_CHANGED)));
}
return(Json(new ResponseJsonModel(error: Messages.ERROR_INVALID_EMAIL)));
}
public ActionResult ListAllUser()
{
var result = _service.GetListUser();
int totalData = result.Count;
if (totalData > 0)
{
var model = new UserJsonModel
{
Have_Data = true,
Total_Data = totalData
};
List <UserModel> list = new List <UserModel>();
UserModel _user;
int index = 0;
foreach (var item in result)
{
index++;
_user = new UserModel
{
No = index,
FullName = item.FullName,
Email = item.Email,
PhoneNo = item.PhoneNo,
Role = item.UserRole
};
list.Add(_user);
}
model.Data = list;
var jsonResult = new JsonResult
{
Data = model,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
return(Json(model, JsonRequestBehavior.AllowGet));
}
return(null);
}
public ActionResult GetWishlists()
{
var userid = WebSecurity.CurrentUserId;
using (var db = new WishlistContext())
{
var jsonModel = new UserJsonModel
{
UserID = userid,
UserName = WebSecurity.CurrentUserName,
Wishlists =
db.Wishlists
.Where(wl => wl.UserId == userid)
.AsEnumerable()
.Select(wl => new WishlistFullJsonModel
{
Info = new WishlistJsonModel
{
ID = wl.WishlistId,
Title = wl.WishlistTitle,
IsPublic = wl.IsPublic
},
WishlistItems =
wl.WishlistItems
.AsEnumerable()
.Select(wli => new WishlistItemJsonModel
{
ID = wli.WishlistItemId,
Content = wli.WishlistItemContent
})
.ToArray()
})
.ToArray()
};
return(Json(jsonModel));
}
}
public bool ChangeRole(UserJsonModel model)
{
var user = DbContext.Users
.Include(u => u.UserRoles)
.SingleOrDefault(c => c.Id == model.Id);
if (user != null)
{
user.UserRoles.Clear();
if (model.IsAdmin)
{
var adminRole = DbContext.Roles.SingleOrDefault(r => r.Name == UserRoles.Admin.ToString());
var userRole = new UserRole {
UserId = user.Id, RoleId = adminRole.Id
};
DbContext.UserRoles.Add(userRole);
}
DbContext.SaveChanges();
return(true);
}
return(false);
}
private static string MapApplicationDataAndReturnXmlResult(UserJsonModel jsonModel)
{
UserXmlModel xmlModel = new UserXmlModel
{
Id = jsonModel.Id,
UserName = jsonModel.FirstName + ' ' + jsonModel.LastName,
DateOfBirth = jsonModel.DateOfBirth
};
xmlModel.Id = jsonModel.Id;
XmlSerializer serializer = new XmlSerializer(xmlModel.GetType());
string result = string.Empty;
using (MemoryStream memStm = new MemoryStream())
{
serializer.Serialize(memStm, xmlModel);
memStm.Position = 0;
result = new StreamReader(memStm).ReadToEnd();
}
return(result);
}
public static async System.Threading.Tasks.Task RunAsync([BlobTrigger("samples-json-files/{name}", Connection = "ConnectionStrings:AzureWebJobsStorage")] Stream myBlob,
string name, ILogger log,
[Blob("sample-xml-files/{name}", FileAccess.Write, Connection = "ConnectionStrings:AzureWebJobsStorage")] CloudBlobContainer applicationXmlOutput)
{
log.LogInformation($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
if (myBlob == null || myBlob.Length < 0)
{
log.LogInformation($"Processed blob\n Name:{name} \n is null or empty");
}
JsonSerializer serializer = new JsonSerializer();
UserJsonModel deserializedJson = null;
using (StreamReader sr = new StreamReader(myBlob))
using (JsonReader reader = new JsonTextReader(sr))
{
while (!sr.EndOfStream)
{
deserializedJson = serializer.Deserialize <UserJsonModel>(reader);
}
}
log.LogInformation($"deserialized Json content: {deserializedJson}");
string result = MapApplicationDataAndReturnXmlResult(deserializedJson);
log.LogInformation($"xml content: {result}");
var blobName = name.Replace("json", "xml");
var cloudBlockBlob = applicationXmlOutput.GetBlockBlobReference(blobName);
await cloudBlockBlob.UploadTextAsync(result);
log.LogInformation($"successfull read and upload");
}
public async Task <IActionResult> Register(UserJsonModel model)
{
if (ModelState.IsValid)
{
var user = new User {
UserName = model.UserName, Email = model.Email, LockoutEnabled = false
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await this.SendConfirmationEmail(user);
await _signInManager.SignInAsync(user, isPersistent : true);
}
var res = new ResponseJsonModel(result.Succeeded);
res.Errors = result.Errors.Select(e => e.Description).ToList();
return(Json(res));
}
var errors = ModelState.Values.SelectMany(v => v.Errors).Select(e => e.ErrorMessage).ToList();
return(Json(new ResponseJsonModel(false, errors: errors)));
}
