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();
}
}
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 DeleteLibrary(string id)
{
using (var cntx = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var libs = from q in session.Query <Lok.Unik.ModelCommon.Client.ContentLibrary>() select q;
var lib = libs.ToArray().FirstOrDefault(x => x.Id.ToString() == id);
if (lib != null)
{
foreach (var item in lib.Files)
{
var relativePath = Path.Combine(lib.BasePath, string.Format("{0}.zip", item.Id));
if (File.Exists(relativePath))
{
File.Delete(relativePath);
}
_log.InfoFormat("Deleting {0} stored at {1}", lib.Title, lib.BasePath);
}
}
session.Delete(lib);
if (lib != null)
{
_log.InfoFormat("{0} Library has been deleted successfully", lib.Title);
}
session.SaveChanges();
}
}
}
public void DeleteUserRole(string id)
{
using (var cntx = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var query =
(from libs in session.Query <Lok.Unik.ModelCommon.Client.ContentLibrary>() select libs)
.ToArray();
var temp = query;
for (var i = 0; i < temp.Length; i++)
{
for (var j = 0; j < temp[i].InvitedUsers.Count; j++)
{
var users = new UserManager().GetAll();
foreach (var user in users)
{
if (user.Id.ToString().Equals(id))
{
query[i].InvitedUsers.RemoveAt(j);
}
}
}
}
session.SaveChanges();
}
}
}
public bool SendInvitationEmail(string sendTo, Uri currentUrl, ApplicationUser currentUser, string tenancy)
{
using (ContextRegistry.NamedContextsFor(GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var invitation =
session.Query <Invitation>().FirstOrDefault(
i => i.SentTo == sendTo && i.Status != InvitationStatus.Deleted);
if (invitation == null)
{
return(false);
}
if (currentUrl != null)
{
var emailSender = this.CreateEmailSender(
invitation.SentTo, invitation.Tenancy, invitation.AuthorizationCode.UrlEncodedCode, currentUrl);
emailSender.Send();
}
invitation.DateSent = DateTime.UtcNow;
invitation.Status = invitation.ResentTimes > 0 ? InvitationStatus.ReSent : InvitationStatus.Sent;
invitation.ResentTimes++;
invitation.InvitingUserId = currentUser.PrincipalId;
session.SaveChanges();
new UserManager().SetStatusUserByPrincipalId(invitation.AcceptingAppUserId);
return(true);
}
}
}
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 IEnumerable <Tag> GetTagsFromContentPackage()
{
var tags = new List <Tag>();
using (var ntx = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var query =
(from packages in session.Query <Lok.Unik.ModelCommon.Client.ContentPackage>() select packages).
ToArray();
//foreach (var contentPackage in query)
//{
// tags.AddRange(contentPackage.Tags.Select(tag => new Models.Tag
// {
// Id = tag.Id,
// Name = tag.Attribute,
// Type = tag.Type.ToString(),
// Category = tag.Category.Name,
// CreateDate = tag.CreateDate,
// Color = tag.Category.Color.ToString()
// }));
//}
return(tags);
}
}
}
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 DeletePackage(string id)
{
using (var cntx = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var query =
(from packs in session.Query <Lok.Unik.ModelCommon.Client.ContentPackage>() select packs)
.ToArray()
.FirstOrDefault(x => x.Id.ToString() == id);
session.Delete(query);
session.SaveChanges();
if (query != null)
{
var objPath = Path.Combine(query.ConfigurationRelativePath, string.Format("{0}.zip", query.Id));
if (File.Exists(objPath))
{
File.Delete(objPath);
_log.InfoFormat("{0} has been deleted and removed from '{1}'", query.Name, objPath);
}
}
}
}
}
public DatabaseInfo GetDataBaseConfiguration(string id)
{
using (var session = DocumentStoreLocator.Resolve(DocumentStoreLocator.RootLocation))
{
var dataBaseInfo = session.Load <DatabaseInfo>(id);
if (dataBaseInfo == null)
{
var cf = GetGlobalConfig();
var url = ErrorLoadingConfigValue;
if (cf.ContainsKey(GlobalConfigItemEnum.DefaultDataConnection.EnumName()))
{
url = cf[GlobalConfigItemEnum.DefaultDataConnection.EnumName()].Value;
}
return(new DatabaseInfo
{
Url = url
});
}
return(dataBaseInfo);
}
}
public void SaveDatabaseConfiguration(string id, DatabaseInfo data)
{
using (var session = DocumentStoreLocator.Resolve(DocumentStoreLocator.RootLocation))
{
var database = session.Load <DatabaseInfo>(id);
if (database == null)
{
database = new DatabaseInfo
{
Application = "Control Aware",
DatabaseSchemaVersion = "1.0.0.0",
InstallDate = DateTime.UtcNow,
Url = data.Url,
};
session.Store(database);
}
database.Url = data.Url;
session.SaveChanges();
}
SaveGlobalConfigItem(new GlobalConfigItem
{
Name = GlobalConfigItemEnum.DefaultDataConnection.EnumName(),
Value = data.Url
}, GlobalConfigItemEnum.DefaultDataConnection.EnumName());
}
public static void CreateIndexes()
{
using (var nctxs = ContextRegistry.NamedContextsFor(typeof(DeviceManager)))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var config = Catalog.Factory.Resolve <IConfig>();
var dbName = config[CommonConfiguration.DefaultDataDatabase];
var tenancyUris = ContextRegistry.ContextsOf("Tenancy");
if (tenancyUris.Any())
{
var tenancyUri = tenancyUris.First();
var tenancy = tenancyUri.Segments.Count() > 1 ? tenancyUri.Segments[1] : string.Empty;
if (!string.IsNullOrEmpty(tenancy)
&&
!tenancy.Equals(Tenants.SystemOwner, StringComparison.InvariantCultureIgnoreCase))
{
dbName = tenancy;
}
}
var store = session.Advanced.DocumentStore;
IndexesManager.CreateIndexes(store, dbName, typeof(AllDeviceIndex));
}
}
}
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);
}
private static void DeviceHealthStatusInitialize(Kiosk dev)
{
using (
var ctx =
ContextRegistry.NamedContextsFor(ContextRegistry.CreateNamed(ContextRegistry.Kind,
UnikContextTypes.
UnikWarehouseContextResourceKind)))
{
using (var dc = DocumentStoreLocator.ContextualResolve())
{
var deviceHealthChangeEvt = new DeviceHealthStatusEvent
{
DeviceId = dev.Id,
DeviceName = dev.Name,
From = HealthStatus.Unknown,
To = HealthStatus.Green,
DeviceTags = dev.Tags,
TimeChanged = DateTime.UtcNow
};
dc.Store(deviceHealthChangeEvt);
dc.SaveChanges();
}
}
}
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 void DeleteItemPackage(string id)
{
using (var cntx = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var libTarget =
(from libs in session.Query <Lok.Unik.ModelCommon.Client.ContentLibrary>()
where libs.Files.Any(file => file.Id == Guid.Parse(id))
select libs)
.FirstOrDefault();
if (libTarget != null)
{
var tempItem = libTarget.Files.FirstOrDefault(file => file.Id == Guid.Parse(id));
if (tempItem != null)
{
var objPath = Path.Combine(libTarget.BasePath, string.Format("{0}.zip", tempItem.Id));
if (File.Exists(objPath))
{
File.Delete(objPath);
_log.InfoFormat("'{0}' LibraryItem has been removed from '{1}'", tempItem.Title, objPath);
}
libTarget.Files.Remove(tempItem);
}
}
session.SaveChanges();
}
}
}
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 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 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);
}
}
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 IEnumerable <TagCategory> GetAll()
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
return(session.Query <TagCategory>().ToArray());
}
}
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 void AddTagCategories(IEnumerable <TagCategory> newCategories)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(CommonConfiguration.CoreDatabaseRoute))
{
AddTagCategories(newCategories, session);
}
}
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 IDevice SaveNewDevice(IDevice deviceDb)
{
using (var nctxs = ContextRegistry.NamedContextsFor(this.GetType()))
{
using (var session = DocumentStoreLocator.ContextualResolve())
{
var objId = Guid.NewGuid();
deviceDb.Id = objId;
deviceDb.Tags.Add(new Tag
{
Id = Guid.NewGuid(),
Type = TagType.Device,
Attribute = deviceDb.Name,
Value = deviceDb.Name,
CreateDate = DateTime.UtcNow,
Category = new TagCategory
{
Name = objId.ToString(),
Color = CategoryColor.Default
}
});
session.Store(deviceDb);
session.SaveChanges();
return(deviceDb);
}
}
}
/// <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));
}
}
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);
}
