public async Task <IActionResult> Index()
{
var userWardrobe = await _avatarService.GetUserWardrobeAsync();
if (userWardrobe.Count == 0)
{
ShowAlertDanger("Avatars have not been configured.");
_logger.LogError("User {id} tried to customize their avatar but avatars have not been configured!",
GetActiveUserId());
return(RedirectToAction(nameof(HomeController.Index), HomeController.Name));
}
var layerGroupings = userWardrobe
.GroupBy(_ => _.GroupId)
.Select(_ => _.ToList())
.ToList();
var usersresult = await _avatarService.GetUserUnlockBundlesAsync();
var viewModel = new AvatarViewModel
{
LayerGroupings = layerGroupings,
Bundles = usersresult,
DefaultLayer = userWardrobe.First(_ => _.DefaultLayer).Id,
ImagePath = _pathResolver.ResolveContentPath($"site{GetCurrentSiteId()}/avatars/")
};
var userAvatar = await _avatarService.GetUserAvatarAsync();
viewModel.NewAvatar = userAvatar.Count == 0;
return(View(viewModel));
}
public async Task <IActionResult> Index()
{
var userWardrobe = await _avatarService.GetUserWardrobeAsync();
if (userWardrobe.Count == 0)
{
ShowAlertDanger("Avatars have not been set up.");
return(RedirectToAction("Index", "Home"));
}
AvatarJsonModel model = new AvatarJsonModel();
model.Layers = _mapper
.Map <ICollection <AvatarJsonModel.AvatarLayer> >(userWardrobe);
var layerGroupings = userWardrobe
.GroupBy(_ => _.GroupId)
.Select(_ => _.ToList())
.ToList();
AvatarViewModel viewModel = new AvatarViewModel()
{
LayerGroupings = layerGroupings,
DefaultLayer = userWardrobe.Where(_ => _.DefaultLayer).First().Id,
ImagePath = _pathResolver.ResolveContentPath($"site{GetCurrentSiteId()}/avatars/"),
AvatarPiecesJson = Newtonsoft.Json.JsonConvert.SerializeObject(model)
};
var userAvatar = await _avatarService.GetUserAvatarAsync();
if (userAvatar.Count == 0)
{
viewModel.NewAvatar = true;
}
return(View(viewModel));
}
public ActionResult FileUpload(HttpPostedFileBase file)
{
if (file != null)
{
var ext = Path.GetExtension(file.FileName) ?? "jpg";
string path = Path.Combine(Server.MapPath("~/Content/Avatars/temp"), Guid.NewGuid() + ext);
while (System.IO.File.Exists(path))
{
path = Path.Combine(Server.MapPath("~/Content/Avatars/temp"), Guid.NewGuid() + ext);
}
System.Drawing.Image image = System.Drawing.Image.FromStream(file.InputStream);
var viewModel = new AvatarViewModel
{
Path = Path.Combine("/Content/Avatars/temp", Path.GetFileName(path)),
Width = image.Width,
Height = image.Height
};
var r = new ResizeSettings();
r.Width = viewModel.DisplayWidth;
r.Height = viewModel.DisplayHeight;
ImageResizer.ImageBuilder.Current.Build(image, path, r);
//file.SaveAs(path);
Session["UploadedFile"] = viewModel;
}
// after successfully uploading redirect the user
return(RedirectToAction("UploadPhoto", "Profile"));
}
public async Task <IActionResult> GetLayersItems(
string type, int layerId, int selectedItemId, int bundleId, int[] selectedItemIds)
{
try
{
var layeritems = await _avatarService.GetUsersItemsByLayerAsync(layerId);
var model = new AvatarViewModel
{
ItemPath = _pathResolver.ResolveContentPath($"site{GetCurrentSiteId()}/avatars/")
};
switch (type?.ToUpperInvariant())
{
case "ITEM":
model.LayerItems = layeritems;
model.SelectedItemId = selectedItemId;
model.ItemPath = _pathResolver.ResolveContentPath($"site{GetCurrentSiteId()}/avatars/");
model.LayerId = layerId;
break;
case "COLOR":
model.LayerColors = await _avatarService.GetColorsByLayerAsync(layerId);
model.SelectedItemId = selectedItemId;
model.LayerId = layerId;
break;
default:
model.Bundle = await _avatarService.GetBundleByIdAsync(bundleId);
model.SelectedItemIds = selectedItemIds;
break;
}
if (model.Bundle != null)
{
var lookupIndex = model.SelectedItemIds
.Select(_ => model.SelectedItemIds
.ToList()
.IndexOf(_)
)
.FirstOrDefault(_ => _ != -1);
model.SelectedItemIndex = lookupIndex == -1 ? 0 : lookupIndex;
}
Response.StatusCode = StatusCodes.Status200OK;
return(PartialView("_SlickPartial", model));
}
catch (GraException gex)
{
_logger.LogError(gex,
"Could not retrieve layer items for layer id {layerId}: {Message}",
layerId,
gex.Message);
Response.StatusCode = StatusCodes.Status400BadRequest;
return(Json(new
{
success = false
}));
}
}
public async Task <IActionResult> Avatar()
{
var user = await GetCurrentUserAsync();
var model = new AvatarViewModel(user);
return(View(model));
}
public IActionResult ClearAvatar([FromBody] AvatarViewModel model)
{
if (!_service.ClearAvatar(model))
{
return(StatusCode(500, "Avatar cannot be cleared!"));
}
return(Ok("Avatar cleared successfully!"));
}
public void Models_AvatarViewModel_Default_Instantiate_Should_Pass()
{
// Act
var result = new AvatarViewModel();
// Assert
Assert.IsNotNull(result, TestContext.TestName);
}
public FrmDadosRefeicao()
{
InitializeComponent();
AvatarView escolido = AvatarViewModel.BuscarporID(1);
this.imgAvatarEscolhido.Source = escolido.imgAvatar;
}
public ActionResult Avatar(AvatarViewModel model, string ExternalImageURL)
{
switch (model.AvatarType)
{
case AvatarType.Url:
if (string.IsNullOrWhiteSpace(model.Url))
{
ModelState.AddModelError("Url", "Enter an avatar url.");
}
break;
case AvatarType.Upload:
List <string> validFormats = new List <string>
{
"image/png", "image/x-png",
"image/gif", "image/x-gif",
"image/jpeg", "image/x-jpeg",
"image/jpg", "image/x-jpg",
};
if (model.Image == null || model.Image.ContentLength == 0)
{
ModelState.AddModelErrorFor <AvatarViewModel>(m => m.Image.FileName, "Please select an image to upload.");
}
else if (!validFormats.Contains(model.Image.ContentType))
{
ModelState.AddModelErrorFor <AvatarViewModel>(m => m.Image, "Invalid file format; only gif,png,jpeg,jpg are allowed.");
}
break;
case AvatarType.None:
default:
break;
}
if (IsModelValidAndPersistErrors())
{
switch (model.AvatarType)
{
case AvatarType.Upload:
string uploadedFileName = _fileServices.UploadAvatar(model.Image);
_userServices.UpdateAvatarToUpload(_currentUser.UserID, uploadedFileName);
break;
case AvatarType.Url:
_userServices.UpdateAvatarToUrl(_currentUser.UserID, model.Url);
break;
case AvatarType.None:
default:
_userServices.UpdateAvatarToNone(_currentUser.UserID);
break;
}
SetSuccess("Profile Settings Updated");
}
return(RedirectToSelf());
}
public async Task<IActionResult> Avatar(bool JustHaveUpdated)
{
var user = await GetCurrentUserAsync();
var model = new AvatarViewModel(user)
{
JustHaveUpdated = JustHaveUpdated
};
return View(model);
}
public FrmDiasSemana()
{
InitializeComponent();
AvatarView escolido = AvatarViewModel.BuscarporID(1);
this.txtNomeApelido.Text = escolido.Name;
this.imgAvatarEscolhido.Source = escolido.imgAvatar;
}
public NewItemPage()
{
InitializeComponent();
BindingContext = viewModel = new AvatarViewModel();
lblCalculoDistancia.Text = "30";
lblIntervaloPosicao.Text = "1";
lblIntervaloPosicaoParado.Text = "30";
saveButton.Clicked += Save_Clicked;
}
// Constructor
public FrmTutorial()
{
InitializeComponent();
AvatarView escolido = AvatarViewModel.BuscarporID(1);
this.imgAvatarEscolhido.Source = escolido.imgAvatar;
this.imgAvatarEscolhido1.Source = escolido.imgAvatar;
this.imgAvatarEscolhido2.Source = escolido.imgAvatar;
this.imgAvatarEscolhido3.Source = escolido.imgAvatar;
this.imgAvatarEscolhido4.Source = escolido.imgAvatar;
this.imgAvatarEscolhido5.Source = escolido.imgAvatar;
}
public async Task <IActionResult> Avatar(bool justHaveUpdated)
{
var user = await GetCurrentUserAsync();
var model = new AvatarViewModel(user)
{
JustHaveUpdated = justHaveUpdated,
NewIconAddres = user.IconFilePath
};
return(View(model));
}
public async Task <AvatarViewModel> GetUserAvatarAsync(ClaimsPrincipal principal)
{
var user = await GetUserAsync(principal);
AvatarViewModel vm = new AvatarViewModel
{
ImagePath = user.FileName,
ImageData = user.FileData
};
return(vm);
}
public async Task <ICollection <Image> > UploadAvatar([FromForm] AvatarViewModel model)
{
ICollection <Image> images = new List <Image>();
var files = model.Files;
if (files != null && files.Any())
{
images = _imageRepository.Save(files, Consts.Folder.User.Name());
await _identityRepository.AddImages(model.Id, images.First());
}
return(images);
}
public async Task <ActionResult> EditAvatar(AvatarViewModel model)
{
if (!ModelState.IsValid)
{
return(View("_Avatar", model));
}
await _userService.UpdateAvatarAsync(UserHelper.Id, model.AttachedImage);
await ResetUserSessionValueAsync();
return(Content("Refresh"));
}
public async Task<IActionResult> Avatar(AvatarViewModel model)
{
var cuser = await GetCurrentUserAsync();
if (!ModelState.IsValid)
{
model.ModelStateValid = false;
model.Recover(cuser);
return View(model);
}
cuser.HeadImgUrl = await _storageService.SaveToOSS(Request.Form.Files.First(), Values.UsersIconBucketId, 365);
await _userService.ChangeProfileAsync(cuser.Id, await _appsContainer.AccessToken(), string.Empty, cuser.HeadImgUrl, string.Empty);
await _userManager.UpdateAsync(cuser);
return RedirectToAction(nameof(Avatar), new { JustHaveUpdated = true });
}
private void ApplicationBarIconButton_Click(object sender, EventArgs e)
{
if (ValidarComponentes.ValidarTextBox(txtNomeApelido, 1))
{
App.Current.Actives.ActiveAvatarP = AvatarViewModel.BuscarporID(1);
App.Current.Actives.ActiveAvatarP.Name = txtNomeApelido.Text;
App.Current.Actives.ActiveAvatarP.Alterar();
NavigationService.Navigate(new Uri("/View/FrmCadastroPerfilPasso01.xaml", UriKind.Relative));
}
else
{
MessageBox.Show("Insira o nome de apelido, por favor", "Erro de preenchimento!", MessageBoxButton.OK);
}
}
public ActionResult EditAvatar(AvatarViewModel model)
{
if (!ModelState.IsValid)
{
return(View("_Avatar", model));
}
var imageFilePath = SaveImage(model.AttachedImage, nameof(EditAvatar));
_userService.UpdateAvatar(UserHelper.UserId.Value, imageFilePath);
ResetUserSessionValue();
return(Content("Refresh"));
}
public async Task <IActionResult> Avatar(AvatarViewModel model)
{
var currentUser = await GetCurrentUserAsync();
if (!ModelState.IsValid)
{
model.Recover(currentUser);
return(View(model));
}
currentUser.IconFilePath = model.NewIconAddress;
await _userService.ChangeProfileAsync(currentUser.Id, await _appsContainer.AccessToken(), currentUser.NickName, currentUser.IconFilePath, currentUser.Bio);
await _userManager.UpdateAsync(currentUser);
return(RedirectToAction(nameof(Avatar), new { JustHaveUpdated = true }));
}
public ActionResult Create([Bind(Include = "Id,Name,DataInHttpPostedFileBase")] AvatarViewModel avatarViewModel)
{
if (ModelState.IsValid)
{
Avatar avatar = new Avatar()
{
Name = avatarViewModel.Name,
Data = ConvertHttpPostedFileBaseToByteArray(avatarViewModel.DataInHttpPostedFileBase)
};
db.Avatar.Add(avatar);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(avatarViewModel));
}
private void Salvar_Click(object sender, EventArgs e)
{
App.Current.Actives.ActivePerfil.Idavatar = 1;
PerfilViewModel.Gravar(App.Current.Actives.ActivePerfil);
MassaView massa = new MassaView()
{
Idmassa = MassaViewModel.listar().Count + 1,
Dataupadate = DateTime.Now.Date,
Massa = App.Current.Actives.ActivePerfil.Peso
};
massa.Gravar();
NavigationService.Navigate(new Uri("/View/FrmMenuInicial.xaml", UriKind.Relative));
Image img = new Image();
img.Source = AvatarViewModel.BuscarporID(1).imgAvatar;
}
public async Task <IActionResult> UploadAvatar(int id)
{
User user = await userManager.FindByIdAsync(id.ToString());
if (user != null)
{
AvatarViewModel avatarModel = new AvatarViewModel {
Id = id
};
if (user.Avatar != null)
{
avatarModel.Delete = true;
}
return(View(avatarModel));
}
return(BadRequest());
}
public async Task <ActionResult> Avatar(AvatarViewModel vm)
{
var path = String.Format(PlatformConfiguration.UploadedUserPathTemplate, UserContext.UserId);
var result = SaveAs(vm.Image, path);
if (result != null)
{
Command.Execute(new UpdateAvatarCommand
{
FileId = result.File.Id
});
}
await SignInManager.UpdateClaims(UserContext);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Upload(AvatarViewModel model)
{
IFormFile file = model.File;
if (file.Length > 0)
{
string path = Path.Combine(_env.WebRootPath, "images");
using (FileStream fs = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
{
await file.CopyToAsync(fs);
}
return(Ok());
}
else
{
return(BadRequest());
}
}
/// <summary>
/// Student's Avatar page
/// </summary>
/// <param name="id">Student Id</param>
/// <returns>Selected Avatar View Model</returns>
// GET: Portal
public ActionResult Avatar(string id = null)
{
// var currentUser = User.Identity.GetUserName();
//var currentUserId = User.Identity.GetUserId();
var myStudent = Backend.StudentBackend.Instance.Read(id);
if (myStudent == null)
{
return(RedirectToAction("Error", "Home"));
}
var myAvatar = Backend.AvatarBackend.Instance.Read(myStudent.AvatarId);
if (myAvatar == null)
{
return(RedirectToAction("Error", "Home"));
}
var SelectedAvatarViewModel = new SelectedAvatarForStudentViewModel();
// Populate the Values to use
SelectedAvatarViewModel.AvatarList = Backend.AvatarBackend.Instance.Index();
// Build up the List of AvatarLevels, each list holds the avatar of that level.
SelectedAvatarViewModel.MaxLevel = SelectedAvatarViewModel.AvatarList.Aggregate((i1, i2) => i1.Level > i2.Level? i1 : i2).Level;
SelectedAvatarViewModel.AvatarLevelList = new List <AvatarViewModel>();
// populate each list at the level
for (var i = 1; i <= SelectedAvatarViewModel.MaxLevel; i++)
{
var tempList = SelectedAvatarViewModel.AvatarList.Where(m => m.Level == i).ToList();
var tempAvatarList = new AvatarViewModel();
tempAvatarList.AvatarList = new List <AvatarModel>();
tempAvatarList.AvatarList.AddRange(tempList);
tempAvatarList.ListLevel = i;
SelectedAvatarViewModel.AvatarLevelList.Add(tempAvatarList);
}
SelectedAvatarViewModel.SelectedAvatar = myAvatar;
SelectedAvatarViewModel.Student = myStudent;
return(View(SelectedAvatarViewModel));
}
public ActionResult Avatar(AvatarViewModel model)
{
if (!ModelState.IsValid)
{
return(View("_Avatar", model));
}
var imageFilePath = SaveImage(model.AttachedImage, nameof(Avatar));
_userService.UpdateAvatar(UserHelper.UserId.Value, imageFilePath);
var userId = UserHelper.UserId;
Session.Remove(USER_ACCOUNT);
Session.Add(USER_ACCOUNT, _userService.GetUser(userId.Value));
return(this.Content("Refresh"));
}
public ActionResult Edit([Bind(Include = "Id,Name,DataInHttpPostedFileBase")] AvatarViewModel avatarViewModel)
{
if (ModelState.IsValid)
{
Avatar avatar = new Avatar();
if (avatarViewModel.DataInHttpPostedFileBase != null)
{
avatar.Data = ConvertHttpPostedFileBaseToByteArray(avatarViewModel.DataInHttpPostedFileBase);
}
avatar.Name = avatarViewModel.Name;
db.Entry(avatar).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(avatarViewModel));
}
public async Task <IActionResult> Avatar(AvatarViewModel model)
{
var cuser = await GetCurrentUserAsync();
if (!ModelState.IsValid)
{
model.ModelStateValid = false;
model.Recover(cuser);
return(View(model));
}
var uploadedProbeFile = await _storageService.SaveToProbe(Request.Form.Files.First(), _configuration["UserIconSiteName"], $"{DateTime.UtcNow.ToString("yyyy-MM-dd")}", SaveFileOptions.RandomName);
cuser.IconFilePath = $"{uploadedProbeFile.SiteName}/{uploadedProbeFile.FilePath}";
await _userService.ChangeProfileAsync(cuser.Id, await _appsContainer.AccessToken(), cuser.NickName, cuser.IconFilePath, cuser.Bio);
await _userManager.UpdateAsync(cuser);
return(RedirectToAction(nameof(Avatar), new { JustHaveUpdated = true }));
}
