public HttpResponseMessage Enrol(string code)
{
ServerUtils.LogTelemetryEvent(User.Identity.Name, "Enrol");
ServiceData.Models.Study found = _studyRepository.Search(
st => st.Code == code
).FirstOrDefault();
ServiceData.Models.User thisUser = _userRepository.Search(
usr => usr.Email == User.Identity.Name
).FirstOrDefault();
if (found != null && thisUser != null &&
!found.StudyEnrolments.Any(en => en.UserId == thisUser.Id))
{
Models.StudyEnrolment enrol = new Models.StudyEnrolment
{
CreatedAt = DateTime.UtcNow,
StudyId = found.Id,
Enrolled = true,
UserId = thisUser.Id
};
var serviceMod = Models.StudyEnrolment.ToServiceModel(enrol, true, true);
var finalRes = _studyEnrolmentRepository.Insert(serviceMod);
return(Request.CreateResponse(HttpStatusCode.OK, finalRes));
}
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
public async Task <HttpResponseMessage> Delete()
{
try
{
ServiceData.Models.User found = _userRepository.Search(u => u.Email == User.Identity.Name).FirstOrDefault();
if (found == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (found.Email != User.Identity.Name)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden));
}
// Delete all conditions and photos from DB and storage
foreach (ServiceData.Models.UserCondition condition in found.Conditions)
{
await UserConditionsController.Delete(_conditionRepository, _shareRepository, _photoRepository, condition.Id);
}
PostLog("Users_Delete", found.Id);
await _userRepository.Delete(found.Id);
ServerUtils.LogTelemetryEvent(User.Identity.Name, "DeleteUser");
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
// PUT api/values/5
public HttpResponseMessage Put(int id, [FromBody] Models.User updatedUser)
{
updatedUser.Id = id;
Models.User found = Models.User.ToAppModel(_userRepository.Search(user => user.Email == updatedUser.Email).FirstOrDefault());
if (found == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (found.Email != User.Identity.Name)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden));
}
if (updatedUser.BirthDate == null)
{
updatedUser.BirthDate = DateTime.UtcNow.AddYears(-30);
}
ServiceData.Models.User final = _userRepository.Update(Models.User.ToServiceModel(updatedUser));
ServerUtils.LogTelemetryEvent(User.Identity.Name, "UpdateUser");
PostLog("Users_Update", final.Id);
return(Request.CreateResponse(HttpStatusCode.OK, Models.User.ToAppModel(final)));
}
protected async Task <bool> IsAdmin()
{
IReadWriteRepository <ServiceData.Models.User> _userRepository = new UserRepository();
ServiceData.Models.User thisUser =
await _userRepository.Search(u => u.Email == User.Identity.Name).FirstOrDefaultAsync();
return(thisUser?.Admin == true);
}
public static User ToAppModel(ServiceData.Models.User given)
{
if (given == null)
{
return(null);
}
User appUser = new User
{
Id = given.Id,
BirthDate = given.BirthDate,
Name = given.Name,
Conditions = new List <UserCondition>(),
Email = given.Email,
Admin = given.Admin
};
if (given.Conditions != null)
{
foreach (ServiceData.Models.UserCondition cond in given.Conditions.ToList())
{
appUser.Conditions.Add(UserCondition.ToAppModel(cond, true));
}
}
if (given.Shares != null)
{
List <Share> shares = new List <Share>();
foreach (ServiceData.Models.Share sh in given.Shares)
{
shares.Add(Share.ToAppModel(sh, false));
}
appUser.Shares = shares;
}
if (given.ManagedStudies != null)
{
List <Study> studies = new List <Study>();
foreach (ServiceData.Models.Study st in given.ManagedStudies)
{
studies.Add(Study.ToAppModel(st, false));
}
appUser.ManagedStudies = studies;
}
if (given.StudyEnrolments != null)
{
List <StudyEnrolment> enrolled = new List <StudyEnrolment>();
foreach (ServiceData.Models.StudyEnrolment st in given.StudyEnrolments)
{
enrolled.Add(StudyEnrolment.ToAppModel(st, true, false));
}
appUser.StudyEnrolments = enrolled;
}
return(appUser);
}
public static ServiceData.Models.User ToServiceModel(User given)
{
ServiceData.Models.User serviceUser = new ServiceData.Models.User
{
Id = given.Id,
BirthDate = given.BirthDate,
Name = given.Name,
Email = given.Email,
Admin = given.Admin
};
if (given.Conditions != null)
{
List <ServiceData.Models.UserCondition> conditions = new List <ServiceData.Models.UserCondition>();
foreach (UserCondition cond in given.Conditions)
{
conditions.Add(UserCondition.ToServiceModel(cond, true));
}
serviceUser.Conditions = conditions;
}
if (given.Shares != null)
{
List <ServiceData.Models.Share> shares = new List <ServiceData.Models.Share>();
foreach (Share sh in given.Shares)
{
shares.Add(Share.ToServiceModel(sh, false));
}
serviceUser.Shares = shares;
}
if (given.ManagedStudies != null)
{
List <ServiceData.Models.Study> studies = new List <ServiceData.Models.Study>();
foreach (Study st in given.ManagedStudies)
{
studies.Add(Study.ToServiceModel(st, false));
}
serviceUser.ManagedStudies = studies;
}
if (given.StudyEnrolments != null)
{
List <ServiceData.Models.StudyEnrolment> enrolled = new List <ServiceData.Models.StudyEnrolment>();
foreach (StudyEnrolment st in given.StudyEnrolments)
{
enrolled.Add(StudyEnrolment.ToServiceModel(st, true, false));
}
serviceUser.StudyEnrolments = enrolled;
}
return(serviceUser);
}
public HttpResponseMessage Get(string password, string email)
{
if (password != ConfidentialData.AdminPassword)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden));
}
ServiceData.Models.User user = _userRepository.Search(u => u.Email == email).FirstOrDefault();
var results = _logRepository.Search(log => log.UserId == user.Id).OrderByDescending(l => l.CreatedAt).Select(l => new Models.EventLog
{
Id = l.Id,
Action = l.Action,
CreatedAt = l.CreatedAt,
UserId = l.UserId
});
return(Request.CreateResponse(HttpStatusCode.OK, results));
}
public async Task <ActionResult> Create([Bind(Include = "Name,Code")] Models.Study study)
{
IReadWriteRepository <ServiceData.Models.User> _userRepository = new UserRepository();
ServiceData.Models.User thisUser =
await _userRepository.Search(u => u.Email == User.Identity.Name).FirstOrDefaultAsync();
study.Active = true;
study.CreatedAt = DateTime.UtcNow;
study.Manager = Models.User.ToAppModel(thisUser);
study.ManagerId = thisUser.Id;
IReadWriteRepository <ServiceData.Models.Study> _studyRepository = new StudyRepository();
bool existing = await _studyRepository.Search(st => st.Code == study.Code).AnyAsync();
if (ModelState.IsValid && !existing)
{
_studyRepository.Insert(Models.Study.ToServiceModel(study, true));
}
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Details([Bind(Include = "Email,Id")] AddParticipantStruct newPart)
{
IReadWriteRepository <ServiceData.Models.User> _userRepository = new UserRepository();
ServiceData.Models.User res =
await _userRepository.Search(u => u.Email == newPart.Email).FirstOrDefaultAsync();
IReadWriteRepository <ServiceData.Models.Study> _studyRepository = new StudyRepository();
ServiceData.Models.Study study = _studyRepository.GetById(newPart.Id);
if (study == null)
{
return(RedirectToAction("Index"));
}
else if (res != null &&
study.Manager.Email == User.Identity.Name &&
!study.StudyEnrolments.Any(en => en.UserId == res.Id))
{
Models.StudyEnrolment enrol = new Models.StudyEnrolment
{
CreatedAt = DateTime.UtcNow,
Study = Models.Study.ToAppModel(study, false),
StudyId = study.Id,
Enrolled = true,
User = Models.User.ToAppModel(res),
UserId = res.Id
};
IReadWriteRepository <ServiceData.Models.StudyEnrolment> _enrolRepository = new StudyEnrolmentRepository();
var serviceMod = Models.StudyEnrolment.ToServiceModel(enrol, true, true);
var finalRes = _enrolRepository.Insert(serviceMod);
return(RedirectToAction("Details", new { id = study.Id }));
}
return(RedirectToAction("Details", new { id = study?.Id }));
}
// GET api/values/5
public HttpResponseMessage Get(int id)
{
ServiceData.Models.User found = _userRepository.GetById(id);
if (found == null)
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
if (found.Email != User.Identity.Name)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden));
}
Models.User toRet = Models.User.ToAppModel(found);
if (toRet.BirthDate == null || (DateTime.UtcNow - toRet.BirthDate).TotalDays < 2)
{
toRet.BirthDate = DateTime.UtcNow.AddYears(-30);
}
ServerUtils.LogTelemetryEvent(User.Identity.Name, "GetUser");
PostLog("Users_GetSingle", found.Id);
return(Request.CreateResponse(HttpStatusCode.OK, toRet));
}
public async Task <HttpResponseMessage> Get()
{
try
{
string[] testUsers = new string[]
{
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**",
"*****@*****.**"
};
string baseFileLoc = "C:/Users/tgs03_000/Downloads/SkinSelfies";
//if (Directory.Exists(baseFileLoc))
//{
// Directory.Delete(baseFileLoc, true);
//}
if (!Directory.Exists(baseFileLoc))
{
Directory.CreateDirectory(baseFileLoc);
}
List <Task> allTasks = new List <Task>();
List <string> nullEmails = new List <string>();
foreach (string userEmail in testUsers)
{
ServiceData.Models.User user = _userRepository.Search(u => u.Email == userEmail).FirstOrDefault();
DirectoryInfo userDir = Directory.CreateDirectory(Path.Combine(baseFileLoc, userEmail));
if (user == null)
{
nullEmails.Add(userEmail);
continue;
}
AboutUser userDetails = new AboutUser
{
Id = user.Id,
Email = user.Email,
Name = user.Name,
Dob = user.BirthDate
};
File.WriteAllText(Path.Combine(userDir.FullName, "AboutUser.txt"), JsonConvert.SerializeObject(userDetails, Formatting.Indented));
foreach (ServiceData.Models.UserCondition cond in user.Conditions)
{
ServiceData.Models.UserCondition fullCond = _conditionRepository.GetById(cond.Id);
string condPath = Path.Combine(userDir.FullName, cond.Id.ToString());
DirectoryInfo condDir = Directory.Exists(condPath)? new DirectoryInfo(condPath) : Directory.CreateDirectory(condPath);
AboutCondition condDetails = new AboutCondition
{
Id = user.Id,
Name = cond.Condition,
SkinRegion = fullCond.SkinRegion.BodyPart.Name + " - " + fullCond.SkinRegion.Name,
StartDate = cond.StartDate,
NumPhotos = fullCond.Photos.Count()
};
File.WriteAllText(Path.Combine(condDir.FullName, "AboutCondition.txt"), JsonConvert.SerializeObject(condDetails, Formatting.Indented));
foreach (ServiceData.Models.Photo photo in fullCond.Photos)
{
string filename = Path.Combine(condDir.FullName, photo.CreatedAt.ToString("yyyy-MM-dd-HH-mm-ss.") + Path.GetExtension(photo.Url));
if (File.Exists(filename))
{
continue;
}
CloudBlobContainer container = await GetBlobContainer();
Stream blobStream = new MemoryStream();
CloudBlob photoBlob = container.GetBlobReference(photo.Url.Replace(ConfidentialData.BlobStorageUrl, ""));
KeyVaultKeyResolver cloudResolver = new KeyVaultKeyResolver(ServerUtils.GetToken);
IKey rsa = await cloudResolver.ResolveKeyAsync(ConfidentialData.KeyLocation, CancellationToken.None);
BlobEncryptionPolicy policy = new BlobEncryptionPolicy(null, cloudResolver);
BlobRequestOptions options = new BlobRequestOptions()
{
EncryptionPolicy = policy
};
await photoBlob.DownloadToStreamAsync(blobStream, null, options, null);
blobStream.Position = 0;
using (var fileStream = File.Create(filename))
{
await blobStream.CopyToAsync(fileStream);
}
}
}
}
string nullString = "";
foreach (string nEmail in nullEmails)
{
nullString += nEmail + ", ";
}
return(Request.CreateResponse(HttpStatusCode.OK, "Files located at " + baseFileLoc + " Null emails: " + nullString));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
}
