public string UploadImage(IFormFile uploadedFile)
{
var member = MemberImpersonated;
CheckFileNameAndSize(uploadedFile);
var updatedMemberImage = CreateUpdatedMemberImage(uploadedFile, member);
var memberImage = Uow.MemberImageRepository.LinkedCacheGetByMemberId(member.Id);
if (memberImage == null)
{
memberImage = new MemberImage().UpdateProperties(updatedMemberImage);
Uow.MemberImageRepository.Insert(memberImage);
}
else
{
memberImage.UpdateProperties(updatedMemberImage);
Uow.MemberImageRepository.Update(memberImage);
}
Uow.Save();
Uow.MemberImageRepository.LinkedCacheClear();
SaveMemberImageToFolder(memberImage);
var urlAvatar = GetUrlAvatar(member.Id);
return(urlAvatar);
}
protected IActionResult MemberImageResult(MemberImage image)
{
if (image == null)
{
return(NoContent());
}
return(File(image.ImageData, image.MimeType));
}
public static MemberImage UpdateProperties(this MemberImage memberImage, MemberImage newMemberImage)
{
memberImage.MemberId = newMemberImage.MemberId;
memberImage.FileNameImage = newMemberImage.FileNameImage;
memberImage.ByteArrayAvatar = newMemberImage.ByteArrayAvatar;
memberImage.ByteArrayIcon = newMemberImage.ByteArrayIcon;
return(memberImage);
}
public async Task <IActionResult> UpdateImage(Guid id, [FromForm] IFormFile file)
{
UpdateMemberImageApiRequest request = await FileToApiRequest(file);
UpdateMemberImage image = _mapper.Map <UpdateMemberImage>(request);
MemberImage updated = await _memberAdminService.UpdateMemberImage(GetMemberId(), id, image);
return(MemberImageResult(updated));
}
public async Task <MemberImage> UpdateMemberImage(Guid currentMemberId, Guid memberId, UpdateMemberImage image)
{
Member member = await GetMember(currentMemberId, memberId, true);
MemberImage updated = await _memberService.UpdateMemberImage(member.Id, image);
_cacheService.RemoveVersionedItem <MemberImage>(memberId);
return(updated);
}
public async Task <MemberImage> RotateMemberImage(Guid currentMemberId, Guid memberId, int degrees)
{
Member member = await GetMember(currentMemberId, memberId);
MemberImage rotated = await _memberService.RotateMemberImage(member.Id, degrees);
_cacheService.RemoveVersionedItem <MemberImage>(memberId);
return(rotated);
}
public async Task <IActionResult> UpdateImage([FromForm] IFormFile file)
{
UpdateMemberImageApiRequest request = await FileToApiRequest(file);
UpdateMemberImage image = _mapper.Map <UpdateMemberImage>(request);
MemberImage updated = await _memberService.UpdateMemberImage(GetMemberId(), image);
return(File(updated.ImageData, updated.MimeType));
}
public async Task <ActionResult> Edit([Bind(Include = "MemberImageId,FileName,Title")] MemberImage memberImage)
{
if (ModelState.IsValid)
{
db.Entry(memberImage).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index", "Members"));
}
ViewBag.MemberImageId = new SelectList(db.Members, "MemberId", "Name", memberImage.MemberImageId);
return(View(memberImage));
}
private async Task <MemberImage> UpdateMemberImage(Member member, byte[] imageData, string mimeType)
{
MemberImage update = CreateMemberImage(member.Id, mimeType, imageData);
await _memberRepository.UpdateMemberImage(update);
MemberImage updated = await _memberRepository.GetMemberImage(member.Id);
_cacheService.UpdatedVersionedItem(updated, member.Id);
return(updated);
}
public async Task <MemberImage> RotateMemberImage(Guid memberId, int degrees)
{
Member member = await GetMember(memberId, memberId);
MemberImage image = await _memberRepository.GetMemberImage(memberId);
if (image == null)
{
return(null);
}
byte[] data = _imageService.Rotate(image.ImageData, degrees);
return(await UpdateMemberImage(member, data, image.MimeType));
}
void ReleaseDesignerOutlets()
{
if (ArticleCountLbl != null)
{
ArticleCountLbl.Dispose();
ArticleCountLbl = null;
}
if (AvgArticleRatingLbl != null)
{
AvgArticleRatingLbl.Dispose();
AvgArticleRatingLbl = null;
}
if (AvgBlogRatingLbl != null)
{
AvgBlogRatingLbl.Dispose();
AvgBlogRatingLbl = null;
}
if (BlogCountLbl != null)
{
BlogCountLbl.Dispose();
BlogCountLbl = null;
}
if (MemberImage != null)
{
MemberImage.Dispose();
MemberImage = null;
}
if (MemberNameLbl != null)
{
MemberNameLbl.Dispose();
MemberNameLbl = null;
}
if (MemberReputationLbl != null)
{
MemberReputationLbl.Dispose();
MemberReputationLbl = null;
}
if (SaveBtn != null)
{
SaveBtn.Dispose();
SaveBtn = null;
}
}
private static MemberImage CreateUpdatedMemberImage(IFormFile uploadedFile, Member member)
{
(byte[] byteArrayAvatar, byte[] byteArrayIcon) = CreateByteArrayFromUploadedImageFile(uploadedFile);
var newMemberImage = new MemberImage
{
MemberId = member.Id,
FileNameImage = Guid.NewGuid().ToString("N") + Path.GetExtension(uploadedFile.FileName),
ByteArrayAvatar = byteArrayAvatar,
ByteArrayIcon = byteArrayIcon
};
return(newMemberImage);
}
// GET: MemberImages/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MemberImage memberImage = await db.MemberImages.FindAsync(id);
if (memberImage == null)
{
return(HttpNotFound());
}
return(View(memberImage));
}
public async Task <ActionResult> DeleteConfirmed(int id, string deleteFileName)
{
//delete image file first
PhotoFileManager manager = new PhotoFileManager(PhotoManagerType.Member);
manager.Delete(deleteFileName, false);
MemberImage memberImage = await db.MemberImages.FindAsync(id);
db.MemberImages.Remove(memberImage);
await db.SaveChangesAsync();
return(RedirectToAction("Index", "Members"));
}
public async Task CreateMember(Guid chapterId, CreateMemberProfile profile)
{
await ValidateMemberProfile(chapterId, profile);
ValidateMemberImage(profile.Image.MimeType, profile.Image.ImageData);
Member existing = await _memberRepository.FindMemberByEmailAddress(profile.EmailAddress);
if (existing != null)
{
return;
}
Member create = new Member(Guid.Empty, chapterId, profile.EmailAddress, profile.EmailOptIn, profile.FirstName, profile.LastName,
DateTime.UtcNow, false, false, 0);
Guid id = await _memberRepository.CreateMember(create);
ChapterMembershipSettings membershipSettings = await _chapterRepository.GetChapterMembershipSettings(chapterId);
MemberSubscription subscription = new MemberSubscription(id, SubscriptionType.Trial, create.CreatedDate.AddMonths(membershipSettings.TrialPeriodMonths));
await _memberRepository.UpdateMemberSubscription(subscription);
MemberImage image = CreateMemberImage(id, profile.Image.MimeType, profile.Image.ImageData);
await _memberRepository.AddMemberImage(image);
IEnumerable <MemberProperty> memberProperties = profile.Properties
.Select(x => new MemberProperty(Guid.Empty, id, x.ChapterPropertyId, x.Value));
await _memberRepository.UpdateMemberProperties(id, memberProperties);
string activationToken = RandomStringGenerator.Generate(64);
await _memberRepository.AddActivationToken(new MemberActivationToken(id, activationToken));
Chapter chapter = await _chapterRepository.GetChapter(chapterId);
string url = _settings.ActivateAccountUrl.Interpolate(new Dictionary <string, string>
{
{ "chapter.name", chapter.Name },
{ "token", HttpUtility.UrlEncode(activationToken) }
});
await _emailService.SendEmail(chapter, create.EmailAddress, EmailType.ActivateAccount, new Dictionary <string, string>
{
{ "chapter.name", chapter.Name },
{ "url", url }
});
}
private void SaveMemberImageToFolder(MemberImage memberImage)
{
var pathIcon = Path.Combine(PathIcons(), memberImage.FileNameImage);
var pathAvatar = Path.Combine(PathAvatars(), memberImage.FileNameImage);
if (!File.Exists(pathIcon))
{
File.WriteAllBytes(pathIcon, memberImage.ByteArrayIcon);
}
if (!File.Exists(pathAvatar))
{
File.WriteAllBytes(pathAvatar, memberImage.ByteArrayAvatar);
}
}
// GET: MemberImages/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MemberImage memberImage = await db.MemberImages.FindAsync(id);
if (memberImage == null)
{
return(HttpNotFound());
}
ViewBag.ImageType = PhotoManagerType.Member;
ViewBag.ImageDirectory = PhotoFileManager.StorageDirectoryDetection(PhotoManagerType.Member);
return(View(memberImage));
}
public async Task UpdateMemberImage(MemberImage image)
{
bool memberHasImage = await MemberHasImage(image.MemberId);
if (memberHasImage)
{
await Context
.Update <MemberImage>()
.Set(x => x.ImageData, image.ImageData)
.Set(x => x.MimeType, image.MimeType)
.Where(x => x.MemberId).EqualTo(image.MemberId)
.ExecuteAsync();
}
else
{
await AddMemberImage(image);
}
}
public async Task <VersionedServiceResult <MemberImage> > GetMemberImage(long?currentVersion, Guid memberId, int?size)
{
VersionedServiceResult <MemberImage> result = await _cacheService.GetOrSetVersionedItem(
() => _memberRepository.GetMemberImage(memberId),
memberId,
currentVersion);
if (currentVersion == result.Version)
{
return(result);
}
MemberImage image = result.Value;
if (size != null)
{
byte[] imageData = _imageService.Crop(image.ImageData, size.Value, size.Value);
image = new MemberImage(image.MemberId, imageData, image.MimeType, image.Version);
}
return(new VersionedServiceResult <MemberImage>(image.Version, image));
}
public override BaseResource[] TransformSource(JObject jsonResponse)
{
MemberImage memberImage = new MemberImage();
string imageResourceUri = ((JValue)jsonResponse.SelectToken("ImageResourceUri")).GetText();
if (string.IsNullOrWhiteSpace(imageResourceUri))
{
logger.Warning("No image resource uri info found");
return(null);
}
memberImage.Id = new Uri($"{idNamespace}{imageResourceUri}");
bool?photoTakenDown = ((JValue)jsonResponse.SelectToken("Photo_x0020_Taken_x0020_Down")).GetBoolean();
if (photoTakenDown == true)
{
logger.Verbose("Image information marked as removed");
return(new BaseResource[] { memberImage });
}
var mnisId = ((JValue)jsonResponse.SelectToken("Person_x0020_MnisId"))?.Value;
if (mnisId == null)
{
logger.Warning("No member info found");
return(null);
}
string mnisIdStr = Convert.ToInt32(Convert.ToDouble(mnisId)).ToString();
Uri personUri = IdRetrieval.GetSubject("memberMnisId", mnisIdStr, false, logger);
if (personUri != null)
{
memberImage.MemberImageHasMember = new List <Member>
{
new Member()
{
Id = personUri
}
};
}
else
{
logger.Warning("No person found");
}
var midX = ((JValue)jsonResponse.SelectToken("MidX"))?.Value;
var midY = ((JValue)jsonResponse.SelectToken("MidY"))?.Value;
if (midX == null || midY == null)
{
logger.Warning("No MidX or MidY info found");
return(null);
}
string midXStr = Convert.ToInt32(Convert.ToDouble(midX)).ToString();
string midYStr = Convert.ToInt32(Convert.ToDouble(midY)).ToString();
memberImage.PersonImageFaceCentrePoint = new List <string>
{
string.Format("POINT({0} {1})", midXStr, midYStr)
};
return(new BaseResource[] { memberImage });
}
public async Task <IActionResult> MemberImageRotateLeft()
{
MemberImage image = await _memberService.RotateMemberImage(GetMemberId(), -90);
return(MemberImageResult(image));
}
public async Task AddMemberImage(MemberImage image)
{
await Context
.Insert(image)
.ExecuteAsync();
}
public async Task <IActionResult> RotateImageLeft(Guid id)
{
MemberImage rotated = await _memberAdminService.RotateMemberImage(GetMemberId(), id, -90);
return(MemberImageResult(rotated));
}
