public override string[] GetUsersInRole(string roleName)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
var role =
(from r in session.Query <ApplicationRole>()
where r.Name == roleName && r.ApplicationName == ApplicationName
select r).SingleOrDefault();
if (role != null)
{
if (role.Type == ApplicationRoleType.Owner)
{
return
((from u in session.Query <ApplicationUser>()
where u.AccountRoles.Any(x => x == role.Id)
select u.UserName).ToArray());
}
var usernames = from u in session.Query <ApplicationUser>()
where u.AccountRoles.Any(x => x == role.Id) && u.Tenancy == this.CurrentTenancy
select u.UserName;
return(usernames.ToArray());
}
return(null);
}
}
public void Reschedule(ScheduledItem item)
{
try
{
using (var ds = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
var loadedItem = ds.Load <ScheduledItem>(DataDocument.GetDocumentId(item));
if (!string.IsNullOrWhiteSpace(loadedItem.Recurrence))
{
Recurrence r = JsonConvert.DeserializeObject <Recurrence>(loadedItem.Recurrence);
DateTime nextOccurence = r.GetNextRecurrence();
ds.Store(
new ScheduledItem(loadedItem.UniqueName, loadedItem.Message, loadedItem.Type, loadedItem.Route,
nextOccurence, r));
}
ds.Delete(loadedItem);
ds.SaveChanges();
}
}
catch (Exception ex)
{
var aa = Catalog.Factory.Resolve <IApplicationAlert>();
aa.RaiseAlert(ApplicationAlertKind.System, ex.TraceInformation());
}
}
/// <summary>
/// Get all registered items for the current tenant
/// </summary>
/// <returns></returns>
public IEnumerable <Lok.Unik.ModelCommon.ItemRegistration.ItemRegistration> GetAll()
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
return(GetAll(session));
}
}
public User GetById(Guid userId)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
return(GetById(userId, session));
}
}
public void ChangeRoleUser(Guid userId, string newRoleToChange, string userEmail, ApplicationUser changingUser)
{
var aUser = GetCompleteUserQuery(userId);
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
var newRole = session.Load <ApplicationRole>(newRoleToChange);
if (changingUser.Tenancy.Equals(DefaultRoles.SuperAdmin, StringComparison.OrdinalIgnoreCase))
{
// //no send invitation..
var invitation = new InvitationManager().GetInvitationByEmail(userEmail);
if (invitation != null)
{
var current = session.Load <Invitation>(invitation.Id);
current.Role = newRole.Name;
session.SaveChanges();
}
}
else
{
//tenant
var invitation = new InvitationManager().GetInvitationByEmail(aUser.AppUser.ContactEmail);
if (invitation != null)
{
using (var nctxs = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var sessionInv = DocumentStoreLocator.ContextualResolve())
{
var current = sessionInv.Load <Invitation>(invitation.Id);
current.Role = newRole.Name;
sessionInv.SaveChanges();
}
}
}
}
if (aUser.AppUser == null)
{
return;
}
if (aUser.AppUser.AccountRoles == null)
{
return;
}
var currentUser = session.Load <ApplicationUser>(aUser.AppUser.Id);
if (newRole != null && !currentUser.AccountRoles.Contains(newRole.Id))
{
//Changing current role by the new one
currentUser.AccountRoles.Clear();
currentUser.AccountRoles.Add(newRole.Id);
}
session.SaveChanges();
}
}
public void CreateDefaultCategories()
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
if (session.Query <TagCategory>().ToList().Any())
{
return;
}
var newCategories = new List <TagCategory>
{
new TagCategory {
Color = KnownColor.Red, Name = "Style"
},
new TagCategory {
Color = KnownColor.Blue, Name = "LocationType"
},
new TagCategory {
Color = KnownColor.Green, Name = "Site"
},
new TagCategory {
Color = KnownColor.Cyan, Name = "Model"
},
new TagCategory {
Color = KnownColor.Magenta, Name = "Location"
}
};
AddTagCategories(newCategories, session);
}
}
public void AddTagCategories(IEnumerable <TagCategory> newCategories)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
AddTagCategories(newCategories, session);
}
}
public virtual void DemoteAccount(string toRole, ApplicationUser user = null)
{
Debug.Assert(!string.IsNullOrEmpty(toRole));
if (null == user)
{
IUserContext _uc = Catalog.Factory.Resolve <IUserContext>();
user = _uc.GetCurrentUser();
}
var billingExt =
(ApplicationUserSubscription)user.Extensions.GetOrAdd(ApplicationUserSubscription.Extension,
_ => new ApplicationUserSubscription());
billingExt.BillingPlan = null;
billingExt.SubscriptionEnd = DateTime.UtcNow;
billingExt.BillingStatus = BillingStatus.NotEnrolled;
user.AccountRoles = new List <string>(new[] { toRole });
_dblog.InfoFormat("User {0} demoted to role {1}", user.PrincipalId, toRole);
using (var ds = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
ds.Store(user);
ds.SaveChanges();
}
}
public static void CreateRolesAndNavigationInfo()
{
using (var coreSession = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
CreateRolesAndNavigationInfo(coreSession, true);
}
}
private ApplicationUser GetRavenDbUser(string username, bool userIsOnline)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
ApplicationUser user;
if (Tenants.SuperAdmin == CurrentTenancy)
{
var q = from u in session.Query <ApplicationUser>()
where u.UserName == username select u;
user = q.SingleOrDefault();
}
else
{
var q = from u in session.Query <ApplicationUser>()
where
u.UserName == username &&
u.Tenancy.Equals(CurrentTenancy, StringComparison.OrdinalIgnoreCase)
select u;
user = q.SingleOrDefault();
}
user.IsOnline = userIsOnline;
session.SaveChanges();
return(user);
}
}
public void LoadNavigation(NavigationWrapper navigator)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
LoadNavigation(navigator, session, true);
}
}
public override void UpdateUser(MembershipUser user)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
var q = from u in session.Query <ApplicationUser>()
where u.UserName == user.UserName && u.Tenancy == GetDbUserTenancy(user)
select u;
var dbUser = q.SingleOrDefault();
if (dbUser == null)
{
throw new HttpException("The user to update could not be found.");
}
dbUser.UserName = user.UserName.Trim();
dbUser.ContactEmail = user.Email.Trim();
dbUser.DateCreated = user.CreationDate;
dbUser.DateLastLogin = user.LastLoginDate;
dbUser.IsOnline = user.IsOnline;
dbUser.IsApproved = user.IsApproved;
dbUser.IsLockedOut = user.IsLockedOut;
session.SaveChanges();
}
}
public override bool DeleteUser(string username, bool deleteAllRelatedData)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
try
{
var q = from u in session.Query <ApplicationUser>()
where
u.UserName == username &&
u.Tenancy.Equals(CurrentTenancy, StringComparison.OrdinalIgnoreCase)
select u;
var user = q.SingleOrDefault();
if (user == null)
{
throw new NullReferenceException("User does not exist.");
}
session.Delete(user);
session.SaveChanges();
return(true);
}
catch (Exception ex)
{
EventLog.WriteEntry(ApplicationName, ex.ToString());
return(false);
}
}
}
public override bool RoleExists(string roleName)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
return(session.Query <ApplicationRole>().Any(r => r.Name == roleName || r.Id == roleName));
}
}
public bool UserHasInvitation(string contactEmail, string tenancy, out string code)
{
bool existInvitation;
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
existInvitation = ExistValidInvitation(contactEmail, tenancy, session, out code);
}
if (!existInvitation)
{
if (!DefaultRoles.SuperAdmin.Equals(tenancy, StringComparison.InvariantCultureIgnoreCase))
{
using (ContextRegistry.NamedContextsFor(GetType()))
{
using (var session1 = DocumentStoreLocator.ContextualResolve())
{
existInvitation = ExistValidInvitation(contactEmail, tenancy, session1, out code);
}
}
}
}
return(existInvitation);
}
public static void CreateApplications()
{
var applications = Default().ToList();
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
var query = (from apps in session.Query <Application>() select apps).ToList();
if (!query.Any())
{
Storage(ref applications);
foreach (var application in applications)
{
session.Store(application);
}
session.SaveChanges();
}
var q2 = (from tnts in session.Query <Tenant>() select tnts).ToList();
if (q2.Any())
{
DistributeDefaultApplications(session, q2);
}
}
}
public string GetRoleInvitationForUser(string relationshipAppUserId)
{
string roleInvitation;
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
roleInvitation = GetRoleInvitationFromUserId(relationshipAppUserId, session);
}
if (roleInvitation == null
&&
!TenantManager.CurrentTenancy.Equals(
DefaultRoles.SuperAdmin,
StringComparison.OrdinalIgnoreCase))
{
using (ContextRegistry.NamedContextsFor(GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
roleInvitation = GetRoleInvitationFromUserId(relationshipAppUserId, session);
}
}
}
return(roleInvitation);
}
public void AssignTagsGeneric <T>(Guid id, IList <Tag> tagList, bool clear) where T : ITaggableEntity
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
AssignTagsGeneric <T>(id, tagList, clear, session);
}
}
public IEnumerable <TagCategory> GetAll()
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
return(session.Query <TagCategory>().ToArray());
}
}
public IEnumerable <Tag> GetTagsByCategoryName(EntityType entity, string categoryName)
{
var tags = new List <Tag>();
using (ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
switch (entity)
{
case EntityType.User:
{
var query = session.Query <User>().ToList();
tags.AddRange(query.SelectMany(z => z.Tags.Where(t => t.Category.Name == categoryName)).Distinct().ToList());
}
break;
case EntityType.ItemRegistration:
{
var query = session.Query <ItemRegistration>().ToList();
tags.AddRange(query.SelectMany(z => z.Tags.Where(t => t.Category.Name == categoryName)).Distinct().ToList());
}
break;
}
}
}
return(tags);
}
public void SaveUser(User user, ApplicationUser creatorPrincipal)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
//check if two documents with a reference are stored.
if (user.AppUser != null)
{
session.Store(user.AppUser);
user.AppUserId = user.AppUser.PrincipalId;
}
//Add a default Tag at Create Action
if (user.AppUser != null)
{
user.Tags.Add(new TagManager().AddDefault <User>(user.AppUser.UserName, user.Id.ToString(),
creatorPrincipal.Id));
}
//it should create an Id if it is empty
session.Store(user);
if (user.AppUser != null)
{
user.AppUser.ContainerId = string.Format("Users/{0}", user.Id);
}
session.SaveChanges();
}
}
public static void CleanCoupons(CancellationToken ct)
{
using (var ds = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
var expired = (from c in ds.Query <Coupon>() where c.Expiration < DateTime.UtcNow select c).Take(512);
if (ct.IsCancellationRequested)
{
return;
}
expired.ForEach(ex => ds.Delete(ex));
if (ct.IsCancellationRequested)
{
return;
}
var expiredAC =
(from a in ds.Query <AuthorizationCode>() where a.ExpirationTime < DateTime.UtcNow select a).Take(512);
if (ct.IsCancellationRequested)
{
return;
}
expiredAC.ForEach(ex => ds.Delete(ex));
ds.SaveChanges();
}
}
private static User GetCompleteUserQuery(Guid userId)
{
User aUser;
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
//aUser =
// session.Query<User>().Customize(x => x.Include<User>(u => u.AppUserId)).FirstOrDefault(
// x => x.Id == userId);
aUser = session.Include("AppUserId").Load <User>(userId);
// aUser = session.Load<User>(userId).Customize(x => x.Include<User>(u => u.AppUserId));
if (aUser == null)
{
throw new ApplicationException("User not found " + userId);
}
var appUser = session.Load <ApplicationUser>(aUser.AppUserId);
//aUser.AppUser = session.Load<ApplicationUser>(aUser.AppUserId);
if (appUser == null)
{
throw new ApplicationException("Application User not found " + aUser.AppUserId);
}
aUser.AppUser = appUser;
}
return(aUser);
}
public static void AuthorizeForRole(string role)
{
var pctx = ContextRegistry.ContextsOf("Principal").FirstOrDefault();
if (null == pctx)
{
throw new AuthenticationException("No authenticated identity");
}
var id = pctx.Segments.First();
ApplicationPrincipal pr;
if (!_cachedPrincipals.MaybeGetItem(id, out pr))
{
using (
var dc =
DocumentStoreLocator.ResolveOrRoot(
ContextualAuthorizationConfiguration.PrincipalsStore))
{
pr = dc.Load <ApplicationPrincipal>(id);
_cachedPrincipals.Add(id, pr);
}
}
if (!pr.IsInRole(role))
{
throw new SecurityException(string.Format("principal {0} is not in role {1}", id, role));
}
}
public void ListTagMapping(Guid id, List <string> select)
{
var aUser = GetById(id);
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
var tags = GetTagsFromUser();
var defaultTag = aUser.Tags.FirstOrDefault(t => t.Category.Color == KnownColor.Transparent);
aUser.Tags.Clear();
aUser.Tags.Add(defaultTag);
if (select.Count != 0)
{
foreach (var name in select)
{
if (!string.IsNullOrEmpty(name))
{
aUser.Tags.Add(tags.FirstOrDefault(x => x.Value.Equals(name)));
}
}
}
var current = session.Load <User>(aUser.Id);
List <Tag> userTag = aUser.Tags.Distinct().ToList();
current.Tags = userTag;
session.SaveChanges();
}
}
public bool DeleteById(Guid id)
{
using (var mainSession = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
using (var session = ReturnContext())
{
var invitation =
session.Query <Invitation>().SingleOrDefault(i => i.Id == id && i.Status != InvitationStatus.Deleted);
if (invitation != null)
{
invitation.Status = InvitationStatus.Deleted;
var user = mainSession.Load <User>(invitation.AcceptingUserId);
var appUser = mainSession.Load <ApplicationUser>(user.AppUserId);
appUser.Status = UserStatus.Deleted;
mainSession.SaveChanges();
session.SaveChanges();
return(true);
}
}
}
return(false);
}
public void ScheduleJobOnlyOnce <T>(string uniqueName, T jobInfo, DateTime schedule, Recurrence r = null,
string jobRoute = null) where T : class
{
Debug.Assert(null != jobInfo);
bool exists;
using (var ds = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
exists = ds.Query <ScheduledItem>().Any(i => i.UniqueName == uniqueName);
}
if (!exists)
{
var log = ClassLogger.Create(typeof(JobDocumentsScheduler));
log.InfoFormat("Scheduling job: {0} at time {1}, recurring: {2}, route = {3}", jobInfo, schedule,
r == null ? string.Empty : r.ToString(), jobRoute);
using (var ds = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
ds.Store(new ScheduledItem(uniqueName, JsonConvert.SerializeObject(jobInfo, _settings),
typeof(T), jobRoute, schedule, r));
ds.SaveChanges();
}
}
}
public Invitation GetInvitationByAuthCode(string code)
{
var invitingTenant = InvitationAuthCode.GetInvitingTenancyFromCode(code);
if (!string.IsNullOrEmpty(invitingTenant))
{
Invitation invitation;
using (
var session = invitingTenant.Equals(
DefaultRoles.SuperAdmin, StringComparison.InvariantCultureIgnoreCase)
? DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute)
: DocumentStoreLocator.Resolve(
string.Format(
"{0}{1}/{2}",
DocumentStoreLocator.SchemeRavenRoute,
UnikContextTypes.UnikTenantContextResourceKind,
invitingTenant)))
{
invitation = SearchInvitationByCode(code, session);
}
return(invitation);
}
return(null);
}
/// <summary>
/// Gets a registration item by id
/// </summary>
/// <param name="itemId"></param>
/// <returns></returns>
public Lok.Unik.ModelCommon.ItemRegistration.ItemRegistration GetById(Guid itemId)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
return(session.Load <Lok.Unik.ModelCommon.ItemRegistration.ItemRegistration>(itemId));
}
}
internal MessageExchangeDeclaration RefreshExchangeSpec(string name)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(MessageBusSpecifierLocalConfig.HostConnectionString))
{
return(session.Load <MessageExchangeDeclaration>(name));
}
}
