public void DeleteFromDb(string DiskFullPath, SiteDb sitedb)
{
var NonRoutable = DiskPathService.GetNonRoutableObject(DiskFullPath);
if (NonRoutable != null)
{
var repo = sitedb.GetRepository(NonRoutable.StoreName);
string name = string.IsNullOrWhiteSpace(NonRoutable.Name) ? NonRoutable.Id.ToString() : NonRoutable.Name;
var result = repo.GetByNameOrId(name) as ISiteObject;
if (result != null)
{
repo.Delete(result.Id);
}
}
else
{
var RelativeUrl = DiskPathService.GetRelativeUrl(sitedb.WebSite, DiskFullPath);
var route = sitedb.Routes.GetByUrl(RelativeUrl);
if (route != null)
{
var repo = sitedb.GetRepository(route.DestinationConstType);
if (repo != null)
{
var result = repo.Get(route.objectId) as ISiteObject;
if (result != null)
{
repo.Delete(result.Id);
}
}
}
}
}
public static void DeleteDiskFolder(string FullPath, SiteDb SiteDb)
{
string nonroutable = DiskPathService.GetNonRoutableFolder(FullPath);
if (!string.IsNullOrEmpty(nonroutable))
{
// delete all routable..
var repo = SiteDb.GetRepository(nonroutable);
if (repo != null)
{
var all = repo.All();
foreach (var item in all)
{
repo.Delete(item.Id);
}
}
}
else
{
// delete all.
var relative = DiskPathService.GetRelativeUrl(SiteDb.WebSite, FullPath);
if (!string.IsNullOrEmpty(relative))
{
relative = relative.ToLower();
if (!relative.EndsWith("/"))
{
relative = relative + "/";
}
List <Route> routesToRemove = new List <Route>();
foreach (var item in SiteDb.Routes.All())
{
if (item.Name.ToLower().StartsWith(relative))
{
routesToRemove.Add(item);
}
}
foreach (var item in routesToRemove)
{
if (item.objectId != default(Guid))
{
var repo = SiteDb.GetRepository(item.DestinationConstType);
repo.Delete(item.objectId);
SiteDb.Routes.Delete(item.Id);
}
}
}
}
}
public static void RollBack(SiteDb SiteDb, List <LogEntry> loglist)
{
var stores = loglist.Where(o => o.IsTable == false).ToList();
foreach (var item in stores.GroupBy(o => o.StoreName))
{
var SingleStoreList = item.ToList();
var repo = SiteDb.GetRepository(item.Key);
if (repo != null)
{
repo.RollBack(SingleStoreList);
}
}
var tables = loglist.Where(o => o.IsTable).ToList();
var kdb = Kooboo.Data.DB.GetKDatabase(SiteDb.WebSite);
foreach (var item in tables.GroupBy(o => o.TableName))
{
var tablelist = item.ToList();
var table = kdb.GetOrCreateTable(item.Key);
table.RollBack(tablelist);
}
}
public static void DeleteRoutableObject(SiteDb sitedb, IRepository repo, ISiteObject value)
{
// delete route..
//TODO:
// Sites.Helper.ChangeHelper.DeleteUrl(this.SiteDb,)
var objectroutes = sitedb.Routes.Query.Where(o => o.objectId == value.Id).SelectAll();
foreach (var item in objectroutes)
{
var referredby = sitedb.Relations.GetReferredByRelations(item.Id);
foreach (var by in referredby)
{
var repofrom = sitedb.GetRepository(by.ConstTypeX);
if (repofrom != null)
{
Sites.Helper.ChangeHelper.DeleteUrl(sitedb, repofrom, by.objectXId, item.Name);
}
}
var stillusedby = sitedb.Relations.Query.Where(o => o.objectYId == item.Id).SelectAll();
if ((stillusedby == null || stillusedby.Count == 0 || (stillusedby.Count == 1 && stillusedby[0].objectXId == value.Id)))
{
sitedb.Routes.Delete(item.Id);
}
else
{
item.objectId = default(Guid);
sitedb.Routes.AddOrUpdate(item);
}
}
}
/// <summary>
/// Check a new website, include the lastest log id.
/// </summary>
/// <param name="OldWebSite"></param>
/// <param name="NewWebSite"></param>
/// <param name="LatestLogId"></param>
public static void CheckOut(SiteDb OldDb, SiteDb NewDb, long LatestLogId, bool SelfInclude = true)
{
foreach (var item in OldDb.ActiveRepositories())
{
var type = item.ModelType;
if (Kooboo.Lib.Reflection.TypeHelper.HasInterface(item.ModelType, typeof(ICoreObject)))
{
var destrepo = NewDb.GetRepository(item.StoreName);
if (destrepo != null)
{
item.CheckOut(LatestLogId, destrepo, true);
}
}
}
foreach (var item in OldDb.TransferTasks.All())
{
NewDb.TransferTasks.AddOrUpdate(item);
}
var setting = Sync.ImportExport.GetSiteSetting(OldDb.WebSite);
Sync.ImportExport.SetSiteSetting(NewDb.WebSite, setting);
Kooboo.Data.GlobalDb.WebSites.AddOrUpdate(NewDb.WebSite);
}
public static ISiteObject GetSiteObject(SiteDb SiteDb, Guid ObjectId, byte ConstType, bool UseColumnOnly = false)
{
var type = ConstTypeService.GetModelType(ConstType);
var repo = SiteDb.GetRepository(type);
if (repo == null || ObjectId == default(Guid))
{
return(null);
}
var siteobject = repo.Get(ObjectId);
if (siteobject != null)
{
return(siteobject as ISiteObject);
}
else
{
var item = repo.GetLastEntryFromLog(ObjectId);
if (item != null)
{
return(item as ISiteObject);
}
}
return(null);
}
public static Sync.SyncObject GetSyncObject(SiteDb SiteDb, LogEntry log, bool GenerateClusterInfo = true)
{
var key = Kooboo.IndexedDB.ByteConverter.GuidConverter.ConvertFromByte(log.KeyBytes);
Sync.SyncObject item = new Sync.SyncObject();
var repo = SiteDb.GetRepository(log.StoreName);
var siteobject = repo.GetByLog(log) as ISiteObject;
if (log.EditType == EditType.Delete)
{
item.IsDelete = true;
item.ObjectConstType = ConstTypeContainer.GetConstType(repo.ModelType);
item.ObjectId = key;
}
else
{
if (siteobject != null)
{
item = Sync.SyncObjectConvertor.ToSyncObject(siteobject);
}
}
if (GenerateClusterInfo)
{
Sync.Cluster.Integrity.Generate(SiteDb, item, log.Id);
}
item.SenderVersion = log.Id;
return(item);
}
/// <summary>
/// get the object display name for log.
/// </summary>
/// <param name="sitedb"></param>
/// <param name="log"></param>
/// <returns></returns>
public static string GetLogDisplayName(SiteDb sitedb, LogEntry log)
{
var repo = sitedb.GetRepository(log.StoreName);
var siteobject = repo?.GetByLog(log);
if (siteobject == null)
{
return(null);
}
if (siteobject is ViewDataMethod)
{
var viewmethod = siteobject as ViewDataMethod;
var view = sitedb.Views.Get(viewmethod.ViewId);
return(view == null ? viewmethod.AliasName : viewmethod.AliasName + "(" + view.Name + ")");
}
if (siteobject is IDataMethodSetting)
{
var methodsetting = siteobject as IDataMethodSetting;
var type = Kooboo.Lib.Reflection.TypeHelper.GetType(methodsetting.DeclareType);
return(type != null ? type.Name + "." + methodsetting.OriginalMethodName : methodsetting.OriginalMethodName);
}
var info = Service.ObjectService.GetObjectInfo(sitedb, siteobject as ISiteObject);
return(info != null ? info.DisplayName : null);
}
public static void ReceiveRemote(SiteDb SiteDb, Sync.SyncObject SyncObject)
{
if (Integrity.Verify(SiteDb, SyncObject))
{
var modeltype = Service.ConstTypeService.GetModelType(SyncObject.ObjectConstType);
var repo = SiteDb.GetRepository(modeltype);
ISiteObject siteobject;
if (SyncObject.IsDelete)
{
siteobject = Activator.CreateInstance(modeltype) as ISiteObject;
repo.Delete(SyncObject.ObjectId);
siteobject.ConstType = SyncObject.ObjectConstType;
siteobject.Id = SyncObject.ObjectId;
}
else
{
siteobject = Sync.SyncObjectConvertor.FromSyncObject(SyncObject);
repo.AddOrUpdate(siteobject);
}
Integrity.AddHistory(SiteDb, SyncObject, siteobject);
}
}
public static SyncObject Prepare(SiteDb SiteDb, LogEntry log)
{
var repo = SiteDb.GetRepository(log.StoreName);
var siteobject = repo.GetByLog(log);
return(Prepare(siteobject, log.StoreName, log.EditType == IndexedDB.EditType.Delete));
}
internal static IRepository GetRepository(SiteDb SiteDb, SyncObject SyncObject)
{
if (!string.IsNullOrEmpty(SyncObject.StoreName))
{
var repo = SiteDb.GetRepository(SyncObject.StoreName);
if (repo != null)
{
return(repo);
}
}
var modeltype = Service.ConstTypeService.GetModelType(SyncObject.ObjectConstType);
if (modeltype != null)
{
var repo = SiteDb.GetRepository(modeltype);
return(repo);
}
return(null);
}
public static List <TValue> List(SiteDb SiteDb, bool cloneObject = true)
{
List <TValue> result = null;
lock (_locker)
{
if (SiteObjects.ContainsKey(SiteDb.Id))
{
var siteobject = SiteObjects[SiteDb.Id];
result = siteobject.Values.ToList();
}
else
{
var repo = SiteDb.GetRepository(typeof(TValue));
if (repo == null)
{
return(new List <TValue>());
}
Dictionary <Guid, TValue> siteobject = new Dictionary <Guid, TValue>();
foreach (var item in repo.All())
{
siteobject[item.Id] = (TValue)item;
}
SiteObjects[SiteDb.Id] = siteobject;
result = siteobject.Values.ToList();
}
}
if (result == null || result.Count == 0)
{
return(new List <TValue>());
}
if (cloneObject)
{
List <TValue> cloned = new List <TValue>();
foreach (var item in result)
{
var newitem = clone(item);
cloned.Add(newitem);
}
return(cloned);
}
else
{
return(result);
}
}
public static void RollBack(SiteDb SiteDb, LogEntry logentry)
{
if (logentry == null)
{
return;
}
var repo = SiteDb.GetRepository(logentry.StoreName);
if (repo != null)
{
repo.RollBack(logentry);
}
}
public static void RollBack(SiteDb SiteDb, List <LogEntry> loglist)
{
foreach (var item in loglist.GroupBy(o => o.StoreName))
{
var SingleStoreList = item.ToList();
var repo = SiteDb.GetRepository(item.Key);
if (repo != null)
{
repo.RollBack(SingleStoreList);
}
}
}
public static string GetObjectRelativeUrl(SiteDb SiteDb, SiteObject SiteObject)
{
if (SiteObject == null)
{
return(null);
}
if (SiteObject is IEmbeddable)
{
var embedded = SiteObject as IEmbeddable;
if (embedded.IsEmbedded)
{
var modeltype = ConstTypeService.GetModelType(embedded.OwnerConstType);
var repo = SiteDb.GetRepository(modeltype);
var parentobject = repo.Get(embedded.OwnerObjectId) as SiteObject;
return(GetObjectRelativeUrl(SiteDb, parentobject));
}
}
if (SiteObject is CmsCssRule)
{
var rule = SiteObject as CmsCssRule;
var style = SiteDb.Styles.Get(rule.ParentStyleId);
return(GetObjectRelativeUrl(SiteDb, style));
}
if (SiteObject is CmsCssDeclaration)
{
var decl = SiteObject as CmsCssDeclaration;
var style = SiteDb.Styles.Get(decl.ParentStyleId);
return(GetObjectRelativeUrl(SiteDb, style));
}
if (Kooboo.Sites.Service.ObjectService.IsRoutable(SiteObject, false))
{
return(SiteDb.Routes.GetObjectPrimaryRelativeUrl(SiteObject.Id));
}
string name = SiteObject.Id.ToString();
if (Attributes.AttributeHelper.IsNameAsId(SiteObject))
{
name = SiteObject.Name;
}
var modeltypex = ConstTypeService.GetModelType(SiteObject.ConstType);
return(Systems.Routes.SystemRouteTemplate.Replace("{objecttype}", modeltypex.Name).Replace("{nameorid}", name));
}
public static void EnsureDeleteRouteObject(SiteDb SiteDb, Route Route)
{
if (Route.objectId != default(Guid))
{
var modeltype = Service.ConstTypeService.GetModelType(Route.DestinationConstType);
var repo = SiteDb.GetRepository(modeltype);
if (repo != null)
{
var Objectitem = repo.Get(Route.objectId);
if (Objectitem != null)
{
repo.Delete(Objectitem.Id);
}
}
}
}
public static ISiteObject GetSiteObject(SiteDb SiteDb, LogEntry log)
{
var repo = SiteDb.GetRepository(log.StoreName);
if (repo == null)
{
return(null);
}
var objectid = KeyConverter.FromByte(log.KeyBytes);
var siteobject = repo.Get(objectid);
if (siteobject == null)
{
siteobject = repo.GetLastEntryFromLog(objectid);
}
return(siteobject);
}
public void Execute(SiteDb sitedb)
{
lock (_locker)
{
var manager = Sync.DiskSyncHelper.GetSyncManager(sitedb.WebSite.Id);
var items = sitedb.Synchronization.GetPushItems(sitedb.Synchronization.DiskSyncSettingId);
foreach (var item in items)
{
var repo = sitedb.GetRepository(item.StoreName);
if (repo == null)
{
return;
}
var siteobject = repo.GetByLog(item);
if (siteobject == null)
{
return;
}
ChangeType changetype = ChangeType.Update;
if (item.EditType == IndexedDB.EditType.Delete)
{
changetype = ChangeType.Delete;
}
else if (item.EditType == IndexedDB.EditType.Add)
{
changetype = ChangeType.Add;
}
manager.SyncToDisk(sitedb, siteobject, changetype, item.StoreName);
// Ensure Double check..... cost performance for integrity.
sitedb.Synchronization.AddOrUpdate(new Models.Synchronization()
{
SyncSettingId = sitedb.Synchronization.DiskSyncSettingId, ObjectId = siteobject.Id, Version = item.Id, In = false, StoreName = repo.StoreName
});
}
}
}
// when undelete a route, should try to undelete its destination object as well.
public static void EnsureRestoreRouteObject(SiteDb SiteDb, Route Route)
{
/// If this is an roll back of an route, if the destination item does not exists.. should try to roll back together..
if (Route.objectId != default(Guid))
{
var modeltype = Service.ConstTypeService.GetModelType(Route.DestinationConstType);
var repo = SiteDb.GetRepository(modeltype);
if (repo != null)
{
var objectitme = repo.Get(Route.objectId);
if (objectitme == null)
{
var lastitem = repo.GetLastEntryFromLog(Route.objectId);
if (lastitem != null)
{
repo.AddOrUpdate(lastitem);
}
}
}
}
}
public static void RollBack(SiteDb SiteDb, LogEntry logentry)
{
if (logentry == null)
{
return;
}
if (logentry.IsTable)
{
var kdb = Kooboo.Data.DB.GetKDatabase(SiteDb.WebSite);
var table = kdb.GetOrCreateTable(logentry.TableName);
table.RollBack(logentry);
}
else
{
var repo = SiteDb.GetRepository(logentry.StoreName);
if (repo != null)
{
repo.RollBack(logentry);
}
}
}
public static void DiskFileRename(SiteDb SiteDb, string OldPath, string NewPath)
{
NonRoutableObject NonRoutable = null;
IRepository repo = null;
NonRoutable = DiskPathService.GetNonRoutableObject(OldPath);
if (NonRoutable != null)
{
var NewNonRoutable = DiskPathService.GetNonRoutableObject(NewPath);
if (NewNonRoutable != null && !string.IsNullOrEmpty(NonRoutable.Name) && !string.IsNullOrEmpty(NewNonRoutable.Name))
{
repo = SiteDb.GetRepository(NonRoutable.StoreName);
var siteobject = repo?.GetByNameOrId(NonRoutable.Name);
if (siteobject == null)
{
return;
}
var oldid = siteobject.Id;
siteobject.Name = NewNonRoutable.Name;
siteobject.Id = default(Guid);
repo.Delete(oldid);
repo.AddOrUpdate(siteobject);
}
}
else
{
string OldRelative = DiskPathService.GetRelativeUrl(SiteDb.WebSite, OldPath);
string NewRelative = DiskPathService.GetRelativeUrl(SiteDb.WebSite, NewPath);
if (!string.IsNullOrEmpty(OldRelative) && !string.IsNullOrEmpty(NewRelative))
{
SiteDb.Routes.ChangeRoute(OldRelative, NewRelative);
}
}
}
public static SyncObject Prepare(SiteDb SiteDb, LogEntry log)
{
if (log.IsTable)
{
var key = Kooboo.IndexedDB.ObjectContainer.GuidConverter.FromByte(log.KeyBytes);
bool isDelete = log.EditType == EditType.Delete;
var kdb = Kooboo.Data.DB.GetKDatabase(SiteDb.WebSite);
var ktable = Kooboo.Data.DB.GetTable(kdb, log.TableName);
if (ktable != null)
{
var data = ktable.GetLogData(log);
return(Prepare(key, data, log.TableName, log.TableColName, log.Id, isDelete));
}
}
else
{
var repo = SiteDb.GetRepository(log.StoreName);
var siteobject = repo.GetByLog(log);
return(Prepare(siteobject, log.StoreName, log.EditType == IndexedDB.EditType.Delete));
}
return(null);
}
/// <summary>
/// verify whether this item can be should be added into the local repository or not.
/// Rule: if local contains a newer version, ignore, otherwise add, update or delete.
/// </summary>
/// <param name="SiteDb"></param>
/// <param name="SyncObject"></param>
/// <returns></returns>
public static bool Verify(SiteDb SiteDb, SyncObject SyncObject)
{
var modeltype = Kooboo.Sites.Service.ConstTypeService.GetModelType(SyncObject.ObjectConstType);
var repo = SiteDb.GetRepository(modeltype);
var historystore = Stores.ClusterUpdateHistory(SiteDb);
var logs = historystore.Where(it => it.ObjectId == SyncObject.ObjectId).SelectAll();
if (logs == null || logs.Count == 0)
{
return(true);
}
var lastlog = logs.OrderByDescending(o => o.SenderTick).First();
if (lastlog.SenderTick > SyncObject.SenderTick)
{
return(false);
}
return(true);
}
// if other routes does not match... find the system route.
public static Route GetSystemRoute(List <String> segments, SiteDb sitedb = null)
{
// public static string SystemRouteTemplate = "/__kb/{objecttype}/{nameorid}"; /{objecttype}/{nameorid}
// public static string SystemRouteTemplateWithAction = "/__kb/{objecttype}/{nameorid}/{action}"; //{objecttype}/{nameorid}/{action}
//Routing.Route actionsystemroute = new Routing.Route();
//actionsystemroute.Name = SystemRouteTemplateWithAction;
//actionsystemroute.objectId = "tempid".ToHashGuid();
//actionsystemroute.DestinationConstType = ConstObjectType.KoobooSystem;
//routes.Add(actionsystemroute);
if (segments == null || segments.Count < 2)
{
return(null);
}
string routename = string.Empty;
var start = segments[0];
Routing.Route sysRoute = new Routing.Route();
sysRoute.objectId = Lib.Security.Hash.ComputeGuidIgnoreCase("___tempid_fake____");
sysRoute.DestinationConstType = ConstObjectType.KoobooSystem;
if (start == "__kb")
{
if (segments.Count == 3)
{
sysRoute.Name = "/__kb/{objecttype}/{nameorid}";
}
else if (segments.Count() == 4)
{
sysRoute.Name = "/__kb/{objecttype}/{nameorid}/{action}";
}
else if (segments.Count() > 4)
{
sysRoute.Name = "/__kb/{objecttype}/{path}";
}
}
else
{
byte output = 0;
Kooboo.Data.Interface.IRepository repo = null;
string nameorid = null;
if (byte.TryParse(start, out output))
{
if (ConstTypeContainer.ByteTypes.ContainsKey(output))
{
if (sitedb != null)
{
repo = sitedb.GetRepository(output);
}
if (segments.Count == 2)
{
sysRoute.Name = "/{objecttype}/{nameorid}";
nameorid = segments[1];
}
else if (segments.Count() == 3)
{
sysRoute.Name = "/{objecttype}/{nameorid}/{action}";
nameorid = segments[1];
}
}
}
else
{
if (ConstTypeContainer.nameTypes.ContainsKey(start))
{
if (sitedb != null)
{
repo = sitedb.GetRepository(start);
}
if (segments.Count == 2)
{
sysRoute.Name = "/{objecttype}/{nameorid}";
nameorid = segments[1];
}
else if (segments.Count() == 3)
{
sysRoute.Name = "/{objecttype}/{nameorid}/{action}";
nameorid = segments[1];
}
}
}
// this kind of route require one more check.
if (sitedb != null && repo != null && nameorid != null)
{
var siteobj = repo.GetByNameOrId(nameorid);
if (siteobj == null)
{
return(null);
}
}
else
{
return(null);
}
}
if (sysRoute.Name != null)
{
return(sysRoute);
}
return(null);
}
public void SyncToDb(string FullPath, SiteDb SiteDb, byte[] diskbytes = null, bool logSync = true)
{
if (diskbytes == null)
{
diskbytes = this.ReadAllBytes(FullPath);
}
if (diskbytes == null)
{
return;
}
if (this.SyncMediator.IsContentHashLock(FullPath, diskbytes))
{
return;
}
//if (!this.SyncMediator.CheckAndAcquireDiskLock(FullPath, diskbytes))
//{
// return;
//}
string OldRelativeUrl = null;
string RelativeUrl = null;
IRepository repo = null;
ISiteObject result = null;
Routing.Route route = null;
string NameFromFile = null;
string extension = UrlHelper.FileExtension(FullPath);
if (!string.IsNullOrEmpty(extension) && !extension.StartsWith("."))
{
extension = "." + extension;
}
if (!string.IsNullOrEmpty(extension))
{
extension = extension.ToLower();
}
var NonRoutable = DiskPathService.GetNonRoutableObject(FullPath);
if (NonRoutable != null)
{
repo = SiteDb.GetRepository(NonRoutable.StoreName);
NameFromFile = NonRoutable.Name;
string name = string.IsNullOrWhiteSpace(NonRoutable.Name) ? NonRoutable.Id.ToString() : NonRoutable.Name;
if (!string.IsNullOrEmpty(NonRoutable.Extension))
{
extension = NonRoutable.Extension.ToLower();
if (!extension.StartsWith("."))
{
extension = "." + extension;
}
}
result = repo.GetByNameOrId(name) as ISiteObject;
if (result == null)
{
if (name.ToLower().EndsWith(extension))
{
name = name.Substring(0, name.Length - extension.Length);
result = repo.GetByNameOrId(name);
}
else
{
name = name + extension;
result = repo.GetByNameOrId(name);
}
}
}
else
{
OldRelativeUrl = DiskPathService.GetRelativeUrl(SiteDb.WebSite, FullPath);
RelativeUrl = Kooboo.Sites.Helper.RouteHelper.ToValidRoute(OldRelativeUrl);
route = SiteDb.Routes.GetByUrl(RelativeUrl);
if (route != null)
{
repo = SiteDb.GetRepository(route.DestinationConstType);
result = repo.Get(route.objectId) as ISiteObject;
}
else
{
var ModelType = Service.ConstTypeService.GetModelTypeByUrl(RelativeUrl);
if (ModelType == null)
{
return;
}
repo = SiteDb.GetRepository(ModelType);
}
NameFromFile = UrlHelper.FileName(RelativeUrl);
}
if (result == null)
{
result = Activator.CreateInstance(repo.ModelType) as ISiteObject;
}
if (!CheckAssignObject(ref result, diskbytes))
{
return;
}
if (result is IExtensionable)
{
var extensionfile = result as IExtensionable;
extensionfile.Extension = extension;
}
if (string.IsNullOrEmpty(result.Name))
{
result.Name = Lib.Helper.StringHelper.ToValidFileName(NameFromFile);
}
if (!string.IsNullOrEmpty(RelativeUrl))
{
SiteDb.Routes.AddOrUpdate(RelativeUrl, result as SiteObject);
}
if (!isSameName(result.Name, NameFromFile, extension) || OldRelativeUrl != RelativeUrl)
{
if (File.Exists(FullPath))
{
this.SyncMediator.AbsoluteLock(FullPath);
File.Delete(FullPath);
this.SyncMediator.LockDisk3Seconds(FullPath);
this.SyncMediator.ReleaseAbsoluteLock(FullPath);
}
repo.AddOrUpdate(result);
}
else
{
this.SyncMediator.AcquireDbLock(result.Id);
repo.AddOrUpdate(result);
this.SyncMediator.ReleaseDbLock(result.Id);
}
if (logSync)
{
var coreobject = result as CoreObject;
SiteDb.Synchronization.AddOrUpdate(new Synchronization {
SyncSettingId = SiteDb.Synchronization.DiskSyncSettingId, ObjectId = coreobject.Id, Version = coreobject.Version, StoreName = repo.StoreName
});
}
}
public static void DeleteComponentFromSource(SiteDb sitedb, ISiteObject value)
{
if (value is IEmbeddable)
{
var embed = value as IEmbeddable;
if (embed.IsEmbedded)
{
// embedded handled by update source.
return;
}
}
var com = Kooboo.Sites.Render.Components.Container.GetByConstType(value.ConstType);
if (com != null)
{
var relations = sitedb.Relations.GetReferredByRelations(value.Id);
if (relations != null && relations.Count > 0)
{
foreach (var relation in relations)
{
var repo = sitedb.GetRepository(relation.ConstTypeX);
var UseObject = repo.Get(relation.objectXId);
if (UseObject != null)
{
if (UseObject is IDomObject)
{
var domobject = UseObject as IDomObject;
if (domobject != null)
{
List <SourceUpdate> updates = new List <SourceUpdate>();
var el = domobject.Dom.getElementsByTagName(com.TagName);
foreach (var item in el.item)
{
if (!string.IsNullOrEmpty(com.StoreEngineName))
{
var engine = item.getAttribute("engine");
if (!Lib.Helper.StringHelper.IsSameValue(engine, com.StoreEngineName))
{
continue;
}
}
if (Lib.Helper.StringHelper.IsSameValue(item.id, value.Name))
{
updates.Add(new SourceUpdate()
{
StartIndex = item.location.openTokenStartIndex, EndIndex = item.location.endTokenEndIndex
});
}
}
string newbody = Service.DomService.UpdateSource(domobject.Body, updates);
domobject.Body = newbody;
repo.AddOrUpdate(domobject);
}
}
}
}
}
}
}
public static void DeleteUrl(SiteDb sitedb, IRepository repo, Guid ObjectId, string OldUrl)
{
var UseObject = repo.Get(ObjectId);
if (UseObject != null)
{
if (UseObject is IDomObject)
{
var domobject = UseObject as IDomObject;
if (domobject != null)
{
string body = domobject.Body;
string newbody = Service.DomService.DeleteUrl(body, OldUrl);
domobject.Body = newbody;
repo.AddOrUpdate(domobject);
}
}
else if (UseObject is Style)
{
var style = UseObject as Style;
style.Body = Lib.Helper.StringHelper.ReplaceIgnoreCase(style.Body, OldUrl, "");
sitedb.Styles.AddOrUpdate(style);
}
else if (UseObject is CmsCssRule)
{
var rule = UseObject as CmsCssRule;
if (rule.IsInline)
{
var rulerepo = sitedb.GetRepository(rule.OwnerObjectConstType);
if (rulerepo != null)
{
var ownerobject = rulerepo.Get(rule.OwnerObjectId);
if (ownerobject != null && ownerobject is IDomObject)
{
var domobject = ownerobject as IDomObject;
var node = Service.DomService.GetElementByKoobooId(domobject.Dom, rule.KoobooId);
if (node != null && node.nodeType == Dom.enumNodeType.ELEMENT)
{
var el = node as Kooboo.Dom.Element;
string style = el.getAttribute("style");
if (!string.IsNullOrEmpty(style))
{
string[] seperators = new string[1];
seperators[0] = ";";
string[] parts = style.Split(seperators, StringSplitOptions.RemoveEmptyEntries);
int count = parts.Length;
for (int i = 0; i < count; i++)
{
if (parts[i].IndexOf(OldUrl, StringComparison.OrdinalIgnoreCase) > -1)
{
parts[i] = "";
}
}
style = string.Join(";", parts);
}
if (string.IsNullOrWhiteSpace(style))
{
el.removeAttribute("style");
}
else
{
el.setAttribute("style", style);
}
string newhtml = Service.DomService.ReSerializeElement(el);
List <SourceUpdate> updates = new List <SourceUpdate>();
updates.Add(new SourceUpdate()
{
StartIndex = el.location.openTokenStartIndex, EndIndex = el.location.endTokenEndIndex, NewValue = newhtml
});
domobject.Body = Service.DomService.UpdateSource(domobject.Body, updates);
rulerepo.AddOrUpdate(domobject);
}
}
}
}
else if (rule.ruleType == RuleType.ImportRule)
{
List <CmsCssRuleChanges> changelist = new List <CmsCssRuleChanges>();
CmsCssRuleChanges changes = new CmsCssRuleChanges();
changes.CssRuleId = rule.Id;
changes.selectorText = rule.SelectorText;
changes.DeclarationText = "";
changes.ChangeType = ChangeType.Delete;
changelist.Add(changes);
Guid parentstyle = rule.ParentStyleId;
if (parentstyle == default(Guid))
{
parentstyle = rule.OwnerObjectId;
}
sitedb.CssRules.UpdateStyle(changelist, parentstyle);
}
else
{
var declaration = Kooboo.Dom.CSS.CSSSerializer.deserializeDeclarationBlock(rule.CssText);
var found = declaration.item.FindAll(o => !string.IsNullOrEmpty(o.value) && o.value.IndexOf(OldUrl, StringComparison.OrdinalIgnoreCase) > -1);
if (found != null && found.Count > 0)
{
foreach (var founditem in found)
{
declaration.item.Remove(founditem);
}
}
string newdecltext = Kooboo.Dom.CSS.CSSSerializer.serializeDeclarationBlock(declaration);
List <CmsCssRuleChanges> changelist = new List <CmsCssRuleChanges>();
CmsCssRuleChanges changes = new CmsCssRuleChanges();
changes.CssRuleId = rule.Id;
changes.selectorText = rule.SelectorText;
changes.DeclarationText = newdecltext;
changes.ChangeType = ChangeType.Update;
changelist.Add(changes);
Guid parentstyle = rule.ParentStyleId;
if (parentstyle == default(Guid))
{
parentstyle = rule.OwnerObjectId;
}
sitedb.CssRules.UpdateStyle(changelist, parentstyle);
}
}
else if (UseObject is ResourceGroup)
{
var oldid = Data.IDGenerator.GetRouteId(OldUrl);
var group = UseObject as ResourceGroup;
group.Children.Remove(oldid);
repo.AddOrUpdate(group);
}
}
}
public static void ChangeUrl(SiteDb sitedb, IRepository repo, Guid ObjectId, string OldUrl, string NewUrl)
{
var UseObject = repo.Get(ObjectId);
if (UseObject != null)
{
if (UseObject is IDomObject)
{
var domobject = UseObject as IDomObject;
if (domobject != null)
{
string body = domobject.Body;
string newbody = Service.DomService.UpdateUrl(body, OldUrl, NewUrl);
domobject.Body = newbody;
repo.AddOrUpdate(domobject);
}
}
else if (UseObject is Style)
{
var style = UseObject as Style;
style.Body = Lib.Helper.StringHelper.ReplaceIgnoreCase(style.Body, OldUrl, NewUrl);
sitedb.Styles.AddOrUpdate(style);
}
else if (UseObject is CmsCssRule)
{
var rule = UseObject as CmsCssRule;
if (rule.IsInline)
{
var rulerepo = sitedb.GetRepository(rule.OwnerObjectConstType);
if (rulerepo != null)
{
var ownerobject = rulerepo.Get(rule.OwnerObjectId);
if (ownerobject != null && ownerobject is IDomObject)
{
var domobject = ownerobject as IDomObject;
var node = Service.DomService.GetElementByKoobooId(domobject.Dom, rule.KoobooId);
if (node != null && node.nodeType == Dom.enumNodeType.ELEMENT)
{
var el = node as Kooboo.Dom.Element;
string style = el.getAttribute("style");
if (!string.IsNullOrEmpty(style))
{
style = Lib.Helper.StringHelper.ReplaceIgnoreCase(style, OldUrl, NewUrl);
}
el.setAttribute("style", style);
string newhtml = Service.DomService.ReSerializeElement(el);
List <SourceUpdate> updates = new List <SourceUpdate>();
updates.Add(new SourceUpdate()
{
StartIndex = el.location.openTokenStartIndex, EndIndex = el.location.endTokenEndIndex, NewValue = newhtml
});
domobject.Body = Service.DomService.UpdateSource(domobject.Body, updates);
rulerepo.AddOrUpdate(domobject);
}
}
}
}
else if (rule.ruleType == RuleType.ImportRule)
{
string newdecltext = Lib.Helper.StringHelper.ReplaceIgnoreCase(rule.RuleText, OldUrl, NewUrl);
List <CmsCssRuleChanges> changelist = new List <CmsCssRuleChanges>();
CmsCssRuleChanges changes = new CmsCssRuleChanges();
changes.CssRuleId = rule.Id;
changes.selectorText = newdecltext; // rule.SelectorText;
changes.DeclarationText = newdecltext;
changes.ChangeType = ChangeType.Update;
changelist.Add(changes);
Guid parentstyle = rule.ParentStyleId;
if (parentstyle == default(Guid))
{
parentstyle = rule.OwnerObjectId;
}
sitedb.CssRules.UpdateStyle(changelist, parentstyle);
}
else
{
var declaration = Kooboo.Dom.CSS.CSSSerializer.deserializeDeclarationBlock(rule.CssText);
foreach (var item in declaration.item)
{
if (item.value.IndexOf(OldUrl, StringComparison.OrdinalIgnoreCase) > -1)
{
item.value = Lib.Helper.StringHelper.ReplaceIgnoreCase(item.value, OldUrl, NewUrl);
}
}
string newdecltext = Kooboo.Dom.CSS.CSSSerializer.serializeDeclarationBlock(declaration);
List <CmsCssRuleChanges> changelist = new List <CmsCssRuleChanges>();
CmsCssRuleChanges changes = new CmsCssRuleChanges();
changes.CssRuleId = rule.Id;
changes.selectorText = rule.SelectorText;
changes.DeclarationText = newdecltext;
changes.ChangeType = ChangeType.Update;
changelist.Add(changes);
Guid parentstyle = rule.ParentStyleId;
if (parentstyle == default(Guid))
{
parentstyle = rule.OwnerObjectId;
}
sitedb.CssRules.UpdateStyle(changelist, parentstyle);
}
}
else if (UseObject is ResourceGroup)
{
var oldid = Data.IDGenerator.GetRouteId(OldUrl);
var group = UseObject as ResourceGroup;
int neworder = 0;
if (group.Children.ContainsKey(oldid))
{
neworder = group.Children[oldid];
}
group.Children.Remove(oldid);
if (NewUrl != null && !NewUrl.ToLower().StartsWith("http://") && !NewUrl.ToLower().StartsWith("https://"))
{
var newid = Data.IDGenerator.GetRouteId(NewUrl);
group.Children[newid] = neworder;
sitedb.ResourceGroups.AddOrUpdate(group);
}
}
}
}
public void SyncToDb(string FullPath, SiteDb SiteDb, byte[] diskbytes = null)
{
if (diskbytes == null)
{
diskbytes = this.ReadAllBytes(FullPath);
}
if (diskbytes == null)
{
return;
}
string OldRelativeUrl = null;
string RelativeUrl = null;
IRepository repo = null;
ISiteObject result = null;
Routing.Route route = null;
string NameFromFile = null;
string extension = UrlHelper.FileExtension(FullPath);
if (!string.IsNullOrEmpty(extension) && !extension.StartsWith("."))
{
extension = "." + extension;
}
if (!string.IsNullOrEmpty(extension))
{
extension = extension.ToLower();
}
var NonRoutable = DiskPathService.GetNonRoutableObject(FullPath);
if (NonRoutable != null)
{
repo = SiteDb.GetRepository(NonRoutable.StoreName);
NameFromFile = NonRoutable.Name;
string name = string.IsNullOrWhiteSpace(NonRoutable.Name) ? NonRoutable.Id.ToString() : NonRoutable.Name;
if (!string.IsNullOrEmpty(NonRoutable.Extension))
{
extension = NonRoutable.Extension.ToLower();
if (!extension.StartsWith("."))
{
extension = "." + extension;
}
}
result = repo.GetByNameOrId(name) as ISiteObject;
if (result == null)
{
if (name.ToLower().EndsWith(extension))
{
name = name.Substring(0, name.Length - extension.Length);
result = repo.GetByNameOrId(name);
}
else
{
name = name + extension;
result = repo.GetByNameOrId(name);
}
}
}
else
{
OldRelativeUrl = DiskPathService.GetRelativeUrl(SiteDb.WebSite, FullPath);
RelativeUrl = Kooboo.Sites.Helper.RouteHelper.ToValidRoute(OldRelativeUrl);
route = SiteDb.Routes.GetByUrl(RelativeUrl);
if (route != null)
{
repo = SiteDb.GetRepository(route.DestinationConstType);
result = repo.Get(route.objectId) as ISiteObject;
}
else
{
var ModelType = Service.ConstTypeService.GetModelTypeByUrl(RelativeUrl);
if (ModelType == null)
{
return;
}
repo = SiteDb.GetRepository(ModelType);
}
NameFromFile = UrlHelper.FileName(RelativeUrl);
}
if (result == null)
{
result = Activator.CreateInstance(repo.ModelType) as ISiteObject;
}
if (!DiskObjectConverter.FromBytes(ref result, diskbytes, SiteDb))
{
return;
}
if (result is IExtensionable)
{
var extensionfile = result as IExtensionable;
extensionfile.Extension = extension;
}
if (string.IsNullOrEmpty(result.Name))
{
result.Name = Lib.Helper.StringHelper.ToValidFileName(NameFromFile);
}
#region "Routing"
if (!string.IsNullOrEmpty(RelativeUrl))
{
SiteDb.Routes.AddOrUpdate(RelativeUrl, result as SiteObject);
}
else
{
// # Rule1, only the API is different...
if (result is Kooboo.Sites.Models.Code)
{
var code = result as Code;
if (code.CodeType == CodeType.Api)
{
bool shouldUpdateCodeRouteText = false;
var diskroute = DiskObjectConverter.GetRouteFromCodeBytes(diskbytes);
if (string.IsNullOrWhiteSpace(diskroute))
{
// # Rule2, Api must have a route defined, otherwise it is a new api.
var newroute = DiskObjectConverter.GetNewRoute(SiteDb, code.Name);
SiteDb.Routes.AddOrUpdate(newroute, code);
shouldUpdateCodeRouteText = true;
}
else
{
// # Rule 3, Check if this is its own route, or someelse routes.
// Own rule, do nothing.
var coderoute = SiteDb.Routes.Get(diskroute);
if (coderoute != null && coderoute.objectId != default(Guid) && coderoute.objectId != code.Id)
{
//Someone else route already. make a new one
diskroute = DiskObjectConverter.GetNewRoute(SiteDb, diskroute);
coderoute = null;
shouldUpdateCodeRouteText = true;
}
if (coderoute == null)
{
//#Rule 4, If route does not exists yet. Add and delte old one if any.
var oldroute = SiteDb.Routes.GetByObjectId(code.Id);
SiteDb.Routes.AddOrUpdate(diskroute, code);
if (oldroute != null)
{
SiteDb.Routes.Delete(oldroute.Id);
}
}
else
{
// donothing.
}
}
if (shouldUpdateCodeRouteText)
{
this.SyncToDisk(SiteDb, code, ChangeType.Update, SiteDb.Code.StoreName);
}
}
}
}
#endregion
if (!isSameName(result.Name, NameFromFile, extension) || OldRelativeUrl != RelativeUrl)
{
if (File.Exists(FullPath))
{
File.Delete(FullPath);
}
repo.AddOrUpdate(result);
}
else
{
repo.AddOrUpdate(result);
}
}
