/////////////////////////////////////////////////////////////////////////////////
// Register Contact / User
/////////////////////////////////////////////////////////////////////////////////
// GET: Register/Contact
public async Task <ActionResult> Contact(Guid organizationId, Guid contactId)
{
GNOrganization organization = await organizationService.Find(organizationId);
GNContact contact = await contactService.Find(contactId);
if (contact != null && contact.IsInviteAccepted.HasValue && contact.IsInviteAccepted.Value)
{
return(RedirectToAction("ContactComplete", new { id = contact.Id }));
}
RegisterContactViewModel model = new RegisterContactViewModel
{
OrgId = organization.Id,
OrgName = organization.Name,
ContactId = contact.Id,
Email = contact.Email,
FirstName = contact.FirstName,
LastName = contact.LastName,
Title = contact.Title,
Phone = contact.Phone,
Fax = contact.Fax,
Website = contact.Website,
StreetAddress1 = contact.StreetAddress1,
StreetAddress2 = contact.StreetAddress2,
City = contact.City,
State = contact.State,
Zip = contact.Zip,
};
return(View(model));
}
public override async Task <List <GNCloudFile> > FindAll(GNContact userContact, int start = 0, int end = 10, Dictionary <string, object> filters = null)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
List <GNCloudFile> entities = null;
if (filters != null && filters.ContainsKey("CloudFileCategory.Name"))
{
var filterVal = (string)filters["CloudFileCategory.Name"];
entities =
await db.GNCloudFiles
.Include(f => f.CloudFileCategory)
.Where(f => f.CloudFileCategory.Name == filterVal)
.OrderByDescending(f => f.CreateDateTime)
.ToListAsync();
}
else
{
entities =
await db.GNCloudFiles
.Include(f => f.CloudFileCategory)
.OrderByDescending(f => f.CreateDateTime)
.ToListAsync();
}
return(EvalEntityListSecurity(userContact, entities));
}
public override async Task <List <GNProject> > FindAll(GNContact userContact, int start = 0, int end = 10, Dictionary <string, object> filters = null)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
IQueryable <GNProject> projects = FindMyProjects(userContact);
//Filter by Filter Keys
if (filters != null && filters.Count != 0)
{
string filterVal = null;
if (filters.ContainsKey("Organization"))
{
filterVal = (string)filters["Organization"];
projects = projects.Where(p => p.Teams.FirstOrDefault().Organization.Name.Contains(filterVal));
}
if (filters.ContainsKey("Team Name"))
{
filterVal = (string)filters["Team Name"];
projects = projects.Where(p => p.Teams.FirstOrDefault().Name.Contains(filterVal));
}
if (filters.ContainsKey("Project Name"))
{
filterVal = (string)filters["Project Name"];
projects = projects.Where(p => p.Name.Contains(filterVal));
}
if (filters.ContainsKey("Project Lead"))
{
filterVal = (string)filters["Project Lead"];
projects = projects.Where(p => p.ProjectLead.FirstName.Contains(filterVal) || p.ProjectLead.LastName.Contains(filterVal));
}
if (filters.ContainsKey("All"))
{
filterVal = (string)filters["All"];
projects = projects
.Where(p => p.Name.Contains(filterVal) ||
p.Teams.FirstOrDefault().Organization.Name.Contains(filterVal) ||
p.Teams.FirstOrDefault().Name.Contains(filterVal) ||
p.ProjectLead.FirstName.Contains(filterVal) ||
p.ProjectLead.LastName.Contains(filterVal));
}
}
//Order By Results
projects = projects
.OrderBy(p => p.ProjectLead.LastName)
.OrderBy(p => p.Teams.FirstOrDefault().Organization.Name)
.OrderBy(p => p.Teams.FirstOrDefault().Name)
.OrderBy(p => p.Name)
.OrderByDescending(t => t.CreateDateTime);
//Limit Result Size
projects = projects.Skip(start).Take(end - start);
return(EvalEntityListSecurity(userContact, await projects.ToListAsync()));
}
public override async Task <GNTeam> Insert(GNContact userContact, object entity)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
GNTeam team = await base.Insert(userContact, entity);
var teamManagerRole = (await this.aspNetRoleService.FindAll()).SingleOrDefault(r => r.Name == "TEAM_MANAGER");
GNTeamMember teamMember = new GNTeamMember()
{
GNTeamId = team.Id,
GNContactId = team.GNContactId,
Team = await Find(userContact, team.Id),
Contact = db.GNContacts.Find(team.GNContactId),
AssignDate = DateTime.Now,
CreateDateTime = DateTime.Now,
CreatedBy = userContact.Id,
CreatedByContact = db.GNContacts.Find(userContact.Id)
};
db.GNTeamMembers.Add(teamMember);
await db.SaveChangesAsync();
return(team);
}
public ActionResult EditMyProfile(GNContact contact)
{
if (ModelState.IsValid)
{
GNContact myProfileContact = this.db.GNContacts.Find(contact.Id);
myProfileContact.FirstName = contact.FirstName;
myProfileContact.LastName = contact.LastName;
myProfileContact.Title = contact.Title;
myProfileContact.Phone = contact.Phone;
myProfileContact.Fax = contact.Fax;
myProfileContact.Website = contact.Website;
myProfileContact.StreetAddress1 = contact.StreetAddress1;
myProfileContact.StreetAddress2 = contact.StreetAddress2;
myProfileContact.City = contact.City;
myProfileContact.State = contact.State;
myProfileContact.Zip = contact.Zip;
this.db.SaveChanges();
return(RedirectToAction("MyProfile"));
}
auditResult = audit.LogEvent(UserContact, Guid.Empty, this.ENTITY, this.Request.UserHostAddress, "EDIT_MY_PROFILE");
return(View(contact));
}
public IQueryable <GNProject> FindMyProjects(GNContact userContact)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
IQueryable <GNProject> projects = null;
//Filter by Role
//GN_ADMIN
if (aspNetRoleService.IsUserContactAdmin(userContact))
{
projects = db.GNProjects;
}
//ORG_MANAGER
else if (userContact.IsInRole("ORG_MANAGER"))
{
projects = db.GNProjects
.Where(p => p.Teams.Select(t => t.OrganizationId).Contains(userContact.GNOrganizationId));
}
//TEAM_MANAGER, PROJECT_MANAGER, TEAM_MEMBER
else
{
projects = db.GNTeams
.Where(t => (
t.OrganizationId == userContact.GNOrganizationId &&
t.TeamMembers.Count(tm => tm.GNContactId == userContact.Id) != 0
)
).SelectMany(t => t.Projects);
}
return(projects);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// My Account - Controller Methods
/////////////////////////////////////////////////////////////////////////////////////////////////////////
#region MyAccountControllerMethods
private void EvalCanViewContact()
{
GNContact contact = new GNContact();
contact = contactService.EvalEntitySecurity(UserContact, contact);
ViewBag.CanViewContact = contact.CanView;
}
public ActionResult MyOrganization()
{
auditResult = audit.LogEvent(UserContact, UserContact.Id, this.ENTITY, this.Request.UserHostAddress, "VIEW_MY_ORGANIZATION");
var contact = (GNContact)ViewBag.ContactForUser;
GNOrganization organization = db.GNOrganizations.Find(contact.GNOrganizationId);
if (organization == null)
{
return(HttpNotFound());
}
//eval CanInvite
GNContact contactObj = new GNContact
{
GNOrganizationId = UserContact.GNOrganizationId
};
contactObj = contactService.EvalEntitySecurity(UserContact, contactObj);
ViewBag.CanInvite = contactObj.CanCreate;
EvalCanViewContact();
return(View(organization));
}
public virtual T EvalEntitySecurity(GNContact userContact, T entity)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
if (entity != null)
{
LogUtil.Info(logger, "Adding entity security info to entity");
var props = entity.GetType().GetProperties().Select(p => p.Name);
if (props.Contains("CanCreate"))
{
entity.GetType().GetProperty("CanCreate").SetValue(entity, true);
}
if (props.Contains("CanView"))
{
entity.GetType().GetProperty("CanView").SetValue(entity, true);
}
if (props.Contains("CanEdit"))
{
entity.GetType().GetProperty("CanEdit").SetValue(entity, true);
}
if (props.Contains("CanDelete"))
{
entity.GetType().GetProperty("CanDelete").SetValue(entity, true);
}
}
LogUtil.Info(logger, "Added entity security info to entity");
return(entity);
}
public virtual List <T> EvalEntityListSecurity(GNContact userContact, List <T> entities)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
if (userContact != null && entities != null)
{
LogUtil.Info(logger, "Adding entity security info to entity list items");
List <T> entitiesSecure = new List <T>();
foreach (var entity in entities)
{
entitiesSecure.Add(EvalEntitySecurity(userContact, entity));
}
;
LogUtil.Debug(logger, "entities.Count = " + entities.Count);
LogUtil.Debug(logger, "entitiesSecure.Count = " + entitiesSecure.Count);
entities = entitiesSecure;
}
if (userContact == null)
{
LogUtil.Warn(logger, "userContact is NULL");
}
LogUtil.Info(logger, "Added entity security info to entity list items");
return(entities);
}
public virtual async Task <int> Delete(GNContact userContact, params object[] keys)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
int result = 0;
object entity = await Find(keys);
entity = EvalEntitySecurity(userContact, (T)entity);
var props = entity.GetType().GetProperties().Select(p => p.Name);
if (!props.Contains("CanDelete") || (bool)entity.GetType().GetProperty("CanDelete").GetValue(entity))
{
LogUtil.Info(logger, "Deleting entity");
result = await Delete(keys);
}
else
{
Exception e = new Exception("Not allowed to delete item.");
LogUtil.Error(logger, e.Message, e);
throw e;
}
LogUtil.Info(logger, "Deleted entity");
return(result);
}
public virtual async Task <T> Update(GNContact userContact, object entity)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
T result = default(T);
db.Entry(entity).State = EntityState.Modified;
entity = EvalEntitySecurity(userContact, (T)entity);
var props = entity.GetType().GetProperties().Select(p => p.Name);
if (!props.Contains("CanEdit") || (bool)entity.GetType().GetProperty("CanEdit").GetValue(entity))
{
LogUtil.Info(logger, "Updating entity");
result = await Update((T)entity);
}
else
{
Exception e = new Exception("Not allowed to update item.");
LogUtil.Error(logger, e.Message, e);
throw e;
}
LogUtil.Info(logger, "Updated entity");
return(result);
}
public virtual async Task <T> Insert(GNContact userContact, object entity)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
T result = default(T);
entity = EvalEntitySecurity(userContact, (T)entity);
var props = entity.GetType().GetProperties().Select(p => p.Name);
if (!props.Contains("CanCreate") || (bool)entity.GetType().GetProperty("CanCreate").GetValue(entity))
{
LogUtil.Info(logger, "Inserting entity");
if (props.Contains("CreatedBy"))
{
entity.GetType().GetProperties().Where(p => p.Name == "CreatedBy").FirstOrDefault().SetValue(entity, userContact.Id);
}
result = await Insert((T)entity);
}
else
{
Exception e = new Exception("Not allowed to create item.");
LogUtil.Error(logger, e.Message, e);
throw e;
}
LogUtil.Info(logger, "Inserted entity");
return(result);
}
public async Task <int> AddRelationship(int TemplateId, GNGene Gene, GNContact userContact)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
int result = 0;
return(await Task.Factory.StartNew <int>(() =>
{
var tx = db.Database.BeginTransaction();
result = db.Database.ExecuteSqlCommand(
"INSERT INTO [gn].[GNTemplateGenes]([GNTemplateId],[GeneCode],[GNGeneId],[CreatedBy],[CreatedDateTime]) " +
"VALUES(@templateId, @geneCode, @geneId, @CreatedBy, @CreateDateTime)",
new SqlParameter("@templateId", TemplateId),
new SqlParameter("@geneCode", Gene.GeneCode),
new SqlParameter("@geneId", Gene.Id),
new SqlParameter("@CreatedBy", userContact.AspNetUserId),
new SqlParameter("@CreateDateTime", DateTime.Now));
tx.Commit();
return result;
}));
//bool auditResult = new GNCloudNoSQLService().LogEvent(userContact, Guid.Parse(leftSampleId), this.ENTITY, "N/A", "INSERT_RELATIONSHIP");
//auditResult = new GNCloudNoSQLService().LogEvent(userContact, Guid.Parse(rigthSampleId), this.ENTITY, "N/A", "INSERT_RELATIONSHIP");
}
private async Task CreateStorageTransactionForCurrentMonth(GNContact userContact, string txnTypeKey)
{
await this.transactionService.CreateTransaction(
userContact, txnTypeKey,
this.transactionService.INITIALIZE_TXN_DESCRIPTION,
0.0, "GB");
}
public async Task <ActionResult> ContactComplete(Guid?id)
{
GNContact contact = await contactService.Find(id);
ViewBag.userForRegContact = this.identityDB.AspNetUsers.Find(contact.AspNetUserId);
return(View(contact));
}
public async Task <bool> AutostartAnalysis(GNAnalysisRequest analysis)
{
AnalysisRequestService analysisService = new AnalysisRequestService(db);
GNContact userContact = db.GNContacts.Find(Guid.Parse("0750f896-e7d6-48d4-a1b9-007059f62784"));
await analysisService.StartAnalysis(userContact, analysis.Id);
return(true);
}
public async Task InitStorageTransactionLogging(GNContact userContact)
{
List <string> txnTypeKeys = await this.db.GNTransactionTypes
.Where(tt => tt.Name.Contains("STORAGE")).Select(tt => tt.Name).ToListAsync();
foreach (var txnTypeKey in txnTypeKeys)
{
await CreateStorageTransactionForCurrentMonth(userContact, txnTypeKey);
}
}
public bool IsUserAssignedToTeam(GNContact userContact, GNTeam team)
{
if (team != null)
{
return(team.TeamMembers.Count(t => t.GNContactId == userContact.Id) != 0);
}
else
{
return(false);
}
}
public bool IsTeamOwnedByOrganization(GNContact userContact, GNTeam team)
{
if (team != null)
{
return(userContact.GNOrganizationId == team.OrganizationId);
}
else
{
return(false);
}
}
private async Task <int> CreateNewInvoices()
{
int result = 1;
if (DateTime.Now.Day == DAY_TO_CREATE_INVOICES)
{
LogUtil.Info(logger, "CreateNewInvoices()...");
System.Console.WriteLine("\nCreateNewInvoices()...");
var db = new GNEntityModelContainer();
InvoiceService invoiceService = new InvoiceService(db);
InvoiceDetailService invoiceDetailService = new InvoiceDetailService(db);
TransactionService transactionService = new TransactionService(db);
AccountService orgAccountService = new AccountService(db);
foreach (var orgAccount in await orgAccountService.FindAll())
{
try
{
LogUtil.Info(logger, "Account = " + orgAccount.Organization.Name);
System.Console.WriteLine("\nAccount = " + orgAccount.Organization.Name);
//get user contact
GNContact userContact = orgAccount.AccountOwner;
if (userContact == null)
{
userContact = db.GNContacts.Where(c => c.GNOrganizationId == orgAccount.Organization.Id).FirstOrDefault();
}
if (userContact != null)
{
string thisCycle = String.Format("{0:yyyyMM}", DateTime.Now);
GNInvoice newInvoiceMonth = invoiceService.GetInvoiceForDateTime(userContact, thisCycle);
if (newInvoiceMonth == null)
{
newInvoiceMonth = await invoiceService.CreateInvoiceForCurrentMonth(userContact, orgAccount);
}
System.Console.WriteLine("\nInvoice for Cycle " + thisCycle + " for Organization " + orgAccount.Organization.Name + " is " + newInvoiceMonth.Id);
LogUtil.Info(logger, "Invoice for Cycle " + thisCycle + " for Organization " + orgAccount.Organization.Name + " is " + newInvoiceMonth.Id);
}
}
catch (Exception ex)
{
result = 0;
LogUtil.Warn(logger, ex.Message, ex);
System.Console.WriteLine(ex.Message);
}
}
}
return(result);
}
private static void ReStartFailedAnalysis(AnalysisRequestService analysisRequestService, GNAnalysisRequest analysisRequest)
{
if (RESTART_ANALYSIS_FEATURE_ACTIVE)
{
try
{
//get analysis request from db
GNAnalysisRequest ar = analysisRequestService.db.GNAnalysisRequests
.Include(a => a.AnalysisType)
.Include(a => a.GNAnalysisRequestGNSamples.Select(s => s.GNSample).Select(s => s.CloudFiles))
.Include(a => a.AnalysisStatus)
.Include(a => a.AnalysisResult)
.Where(a => a.Id == analysisRequest.Id)
.FirstOrDefault();
//determine if analysis re-start is allowed
ar = analysisRequestService.IsValidSampleSet(ar);
ar.CanReStartAnalysis = analysisRequestService.IsAnalysisRestartAllowed(ar, FORCE_RESTART_ANALYSIS);
//restart analysis
if (ar.CanReStartAnalysis && ar.IsFailedRequest)
{
LogUtil.Info(logger, "Restart Analysis for AR ID [" + ar.Id + "]...");
System.Console.WriteLine("\nRestart Analysis for AR ID [" + ar.Id + "]...");
var t = Task.Run(async delegate
{
var arService = new AnalysisRequestService(new GNEntityModelContainer(), new IdentityModelContainer());
//get user contact
GNContact userContact = arService.db.GNContacts.Find(ar.CreatedBy);
if (arService.analysisRequestPendingCloudMessageService == null || arService.cloudStorageService == null)
{
arService.InitCloudServices(userContact.GNOrganization.AWSConfigId);
}
await arService.StartAnalysis(userContact, ar.Id);
});
}
else
{
LogUtil.Info(logger, "UNABLE to Restart Analysis for AR ID [" + ar.Id + "]...");
System.Console.WriteLine("\nUNABLE to Restart Analysis for AR ID [" + ar.Id + "]...");
}
}
catch (Exception e)
{
LogUtil.Error(logger, "Unable to Process Failure of Analysis " + analysisRequest.Id + " : " + e.Message, e);
}
}
}
public override async Task <int> Delete(GNContact userContact, params object[] keys)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
var entityKey = (Guid)keys[0];
db.GNTeamMembers.RemoveRange(db.GNTeamMembers.Where(tm => tm.GNTeamId == entityKey));
int result = await db.SaveChangesAsync();
result = await base.Delete(userContact, entityKey);
return(result);
}
public async Task <List <GNSample> > FindByOrganizationId(GNContact userContact, Guid organizationId)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
List <GNSample> entities =
await db.GNSamples
.Include(g => g.Organization)
.Where(s => s.GNOrganizationId == organizationId)
//.OrderByDescending(s => s.CreateDateTime)
.ToListAsync();
return(EvalEntityListSecurity(userContact, entities));
}
public override AspNetUser EvalEntitySecurity(GNContact userContact, AspNetUser user)
{
LogUtil.LogMethod(logger, MethodBase.GetCurrentMethod());
if (user != null)
{
user.CanCreate = true;
user.CanView = true;
user.CanEdit = true;
user.CanDelete = true;
}
return(user);
}
private bool IsCreatorOfSampleForCloudFile(GNContact userContact, GNCloudFile cloudFile)
{
bool isCreatorOfSample = false;
foreach (var sample in this.db.GNSamples.Where(s => s.CloudFiles.Select(f => f.Id).Contains(cloudFile.Id)))
{
if (sample.CreatedBy != null && sample.CreatedBy != Guid.Empty && userContact.Id == sample.CreatedBy)
{
isCreatorOfSample = true;
break;
}
}
return(isCreatorOfSample);
}
private bool IsCloudFileOwnedByOrganization(GNContact userContact, GNCloudFile cloudFile)
{
bool isOwnedByOrg = false;
foreach (var sample in this.db.GNSamples.Where(s => s.CloudFiles.Select(f => f.Id).Contains(cloudFile.Id)))
{
if (userContact.GNOrganizationId == sample.GNOrganizationId)
{
isOwnedByOrg = true;
break;
}
}
return(isOwnedByOrg);
}
public bool IsUserAssignedToTeamAsLead(GNContact userContact, GNTeam team)
{
if (team != null && team.TeamLead == null)
{
team.TeamLead = db.GNContacts.Find(team.GNContactId);
}
if (userContact != null && team != null && team.TeamLead != null)
{
return(team.TeamLead.Id == userContact.Id);
}
else
{
return(false);
}
}
public async Task <ActionResult> ContactSubmit(RegisterContactViewModel model)
{
if (ModelState.IsValid)
{
string orgId = model.OrgId.ToString();
//Auth or Create User
AspNetUser aspNetUser = await AuthCreateUser(model.Email, model.Password, model.IsExistingUser,
verifyEmail : false, signUpForNews : model.SignUpForNewsAndProducts, organizationId : orgId);
if (ModelState.IsValid && aspNetUser != null)
{
GNContact contact = await contactService.Find(model.ContactId);
contact.AspNetUserId = aspNetUser.Id;
contact.Email = model.Email;
contact.FirstName = model.FirstName;
contact.LastName = model.LastName;
contact.Title = model.Title;
contact.Phone = model.Phone;
contact.Fax = model.Fax;
contact.Website = model.Website;
contact.StreetAddress1 = model.StreetAddress1;
contact.StreetAddress2 = model.StreetAddress2;
contact.City = model.City;
contact.State = model.State;
contact.Zip = model.Zip;
contact.IsInviteAccepted = true;
contact.IsSubscribedForNewsletters = model.SignUpForNewsAndProducts;
contact.TermsAcceptDateTime = DateTime.Now;
contact.PrivacyPolicyAcceptDateTime = DateTime.Now;
contact = await contactService.Update(contact);
if (contact != null)
{
return(RedirectToAction("ContactComplete", new { id = contact.Id }));
}
}
}
return(View(model));
}
public override async Task <T> Find(GNContact userContact, params object[] keys)
{
T entity = await base.Find(userContact, keys);
if (entity != null)
{
var props = entity.GetType().GetProperties().Select(p => p.Name);
if (props.Contains("CreatedBy") && props.Contains("CreatedByContact"))
{
object createdByGuidObj = entity.GetType().GetProperties()
.Where(p => p.Name == "CreatedBy")
.FirstOrDefault()
.GetValue(entity);
if (createdByGuidObj != null)
{
GNContact createdByContact = this.db.GNContacts.Find((Guid)createdByGuidObj);
if (createdByContact != null)
{
entity.GetType().GetProperties()
.Where(p => p.Name == "CreatedByContact")
.FirstOrDefault()
.SetValue(entity, createdByContact);
}
}
}
/*
* if (props.Contains("CreateDateTime"))
* {
* entity.GetType().GetProperties()
* .Where(p => p.Name == "CreateDateTime")
* .FirstOrDefault()
* .SetValue(entity,
* entity.GetType().GetProperties()
* .Where(p => p.Name == "CreateDateTime")
* .FirstOrDefault()
* .GetValue(entity));
* }*/
}
return(entity);
}
