public static bool FromBytes(ref ISiteObject SiteObject, byte[] DiskBytes, SiteDb sitedb)
{
var modeltype = SiteObject.GetType();
var SerializerType = Attributes.AttributeHelper.GetDiskType(modeltype);
if (SerializerType == Kooboo.Attributes.DiskType.Binary)
{
var binaryfile = SiteObject as IBinaryFile;
if (DiskBytes == null || IOHelper.IsEqualBytes(binaryfile.ContentBytes, DiskBytes))
{
return(false);
}
binaryfile.ContentBytes = DiskBytes;
}
else if (SerializerType == Kooboo.Attributes.DiskType.Text)
{
var textfile = SiteObject as ITextObject;
if (SiteObject is Kooboo.Sites.Models.Code)
{
var currentcode = SiteObject as Models.Code;
var bytes = CodeToBytes(sitedb, currentcode);
if (IOHelper.IsEqualBytes(bytes, DiskBytes))
{
return(false);
}
var currentbody = currentcode.Body;
var ok = FromCodeBytes(currentcode, DiskBytes);
if (!ok)
{
return(false);
}
}
else
{
string textbody = System.Text.Encoding.UTF8.GetString(DiskBytes);
if (StringHelper.IsSameValue(textbody, textfile.Body))
{
return(false);
}
textfile.Body = textbody;
}
}
else
{
string fulltext = System.Text.Encoding.UTF8.GetString(DiskBytes);
var generatedbody = Lib.Helper.JsonHelper.Serialize(SiteObject);
if (StringHelper.IsSameValue(generatedbody, fulltext))
{
return(false);
}
SiteObject = JsonHelper.Deserialize(fulltext, modeltype) as ISiteObject;
}
return(true);
}
public bool CanSyncToDisk(ISiteObject value, string StoreName)
{
/// verify if this item has been sync to disk....
/// this is a double, should not happen...
if (value == null)
{
return(false);
}
ICoreObject coreobject = value as ICoreObject;
if (coreobject == null)
{
return(false);
}
var logs = this.Query.Where(o => o.SyncSettingId == this.DiskSyncSettingId && o.ObjectId == value.Id).SelectAll();
foreach (var item in logs)
{
if (Kooboo.Lib.Helper.StringHelper.IsSameValue(StoreName, item.StoreName))
{
if (item.Version >= coreobject.Version)
{
return(false);
}
}
}
this.AddOrUpdate(new Synchronization {
SyncSettingId = this.DiskSyncSettingId, ObjectId = value.Id, Version = coreobject.Version, StoreName = StoreName
});
return(true);
}
public static void AddHistory(SiteDb SiteDb, SyncObject SyncObject, ISiteObject SiteObject)
{
NodeUpdate update = new NodeUpdate();
update.ObjectId = SyncObject.ObjectId;
update.ObjectConstType = SyncObject.ObjectConstType;
update.IsDelete = SyncObject.IsDelete;
update.Language = SyncObject.Language;
update.Sender = SyncObject.Sender;
update.SenderTick = SyncObject.SenderTick;
if (SiteObject is CoreObject)
{
var core = SiteObject as CoreObject;
update.LocalVersion = core.Version;
}
var store = Stores.ClusterUpdateHistory(SiteDb);
var old = store.get(update.Id);
if (old == null)
{
store.add(update.Id, update);
}
}
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);
}
}
}
internal static SyncObject Prepare(ISiteObject SiteObject, string StoreName = null, bool IsDelete = false)
{
SyncObject syncobject = null;
if (IsDelete)
{
syncobject = new SyncObject();
syncobject.IsDelete = true;
syncobject.ObjectConstType = SiteObject.ConstType;
syncobject.ObjectId = SiteObject.Id;
}
else
{
syncobject = SyncObjectConvertor.ToSyncObject(SiteObject);
}
if (string.IsNullOrEmpty(StoreName))
{
StoreName = SiteObject.GetType().Name;
}
syncobject.StoreName = StoreName;
if (SiteObject is ICoreObject)
{
var coreobject = SiteObject as ICoreObject;
syncobject.SenderVersion = coreobject.Version;
}
return(syncobject);
}
public static byte[] GetObjectBytes(ISiteObject siteobject)
{
if (siteobject == null)
{
return(null);
}
var disktype = Kooboo.Attributes.AttributeHelper.GetDiskType(siteobject);
if (disktype == Attributes.DiskType.Text && siteobject is ITextObject)
{
var textobject = siteobject as ITextObject;
if (!string.IsNullOrEmpty(textobject.Body))
{
return(System.Text.Encoding.UTF8.GetBytes(textobject.Body));
}
}
else if (disktype == Attributes.DiskType.Binary && siteobject is IBinaryFile)
{
var binaryfile = siteobject as IBinaryFile;
return(binaryfile.ContentBytes);
}
else
{
string textbody = JsonHelper.Serialize(siteobject);
if (!string.IsNullOrEmpty(textbody))
{
return(System.Text.Encoding.UTF8.GetBytes(textbody));
}
}
return(null);
}
// Add from SiteRepositoryBase Event....
public void AddTask(IRepository repo, ISiteObject value, ChangeType changetype)
{
if (repo == null || value == null)
{
return;
}
var core = value as ICoreObject;
if (core == null)
{
return;
}
lock (_queuelocker)
{
PushTask task = new PushTask()
{
StoreName = repo.StoreName, ObjectId = value.Id
};
if (changetype == ChangeType.Delete)
{
task.Version = GetJustDeltedVersion(repo, value.Id);
task.IsDelete = true;
}
else
{
task.Version = core.Version;
}
this.AddTask(task);
}
}
private List <Guid> _GetUsedByPage(IRepository repo, ISiteObject siteobject)
{
List <Guid> pageids = new List <Guid>();
var usedby = repo.GetUsedBy(siteobject.Id);
foreach (var item in usedby)
{
if (item.ConstType == ConstObjectType.Page)
{
pageids.Add(item.ObjectId);
}
else
{
var newrepo = this.SiteDb.GetRepository(item.ConstType);
if (newrepo != null)
{
var siteobj = newrepo.Get(item.ObjectId);
if (siteobj != null)
{
var usedbyids = _GetUsedByPage(newrepo, siteobj);
pageids.AddRange(usedbyids);
}
}
}
}
return(pageids);
}
public string GetVersion(RenderContext context)
{
if (context == null || context.WebSite == null)
{
return(Data.AppSettings.Version.ToString());
}
var sitedb = context.WebSite.SiteDb();
IRepository repo = null;
if (this.IsGroup)
{
repo = sitedb.ResourceGroups;
}
else if (this.IsImage)
{
repo = sitedb.Images;
}
else if (IsStyle)
{
repo = sitedb.Styles;
}
else
{
repo = sitedb.Scripts;
}
ISiteObject siteobject = null;
// get current version
var route = Kooboo.Sites.Routing.ObjectRoute.GetRoute(sitedb, this.Url);
if (route != null && route.objectId != default(Guid))
{
siteobject = repo.Get(route.objectId);
if (siteobject != null)
{
var core = siteobject as ICoreObject;
if (core != null)
{
return(GetVersion(sitedb, core).ToString());
}
}
}
if (siteobject != null)
{
var core = siteobject as ICoreObject;
if (core != null)
{
return(GetVersion(sitedb, core).ToString());
}
}
return(null);
}
public void Delete(ISiteObject siteobject)
{
if (this.IndexType.Contains(siteobject.ConstType))
{
string meta = GetMetaKey(siteobject);
IndexData.Delete(meta);
}
}
private bool IsEmbedded(ISiteObject Value)
{
if (Value is IEmbeddable)
{
IEmbeddable embedded = Value as IEmbeddable;
return(embedded.IsEmbedded);
}
return(false);
}
public static long GetSize(ISiteObject siteobject)
{
if (siteobject is IBinaryFile)
{
return(((IBinaryFile)siteobject).Size);
}
else
{
var json = Lib.Helper.JsonHelper.Serialize(siteobject);
return(json.Length);
}
}
public void Sync(SiteDb SiteDb, ISiteObject Value, ChangeType ChangeType, string StoreName)
{
if (ChangeType == ChangeType.Add || ChangeType == ChangeType.Update)
{
this.AddOrUpdate(Value);
}
else
{
this.Delete(Value);
}
this.IndexData.Close();
}
private string GetBody(ISiteObject siteobject)
{
string body = null;
if (siteobject is ITextObject)
{
var textobject = siteobject as ITextObject;
body = textobject.Body;
return(Kooboo.Search.Utility.RemoveHtml(body));
}
return(body);
}
private VersionCompareViewModel GetStoreCompareModel(ApiCall call, Sites.Repository.SiteDb sitedb, long id1, long id2)
{
VersionCompareViewModel model = new VersionCompareViewModel()
{
Id1 = id1, Id2 = id2
};
LogEntry prelog = sitedb.Log.Get(id1);
if (prelog != null)
{
var repo = sitedb.GetRepository(prelog.StoreName);
LogEntry nextlog;
if (id2 == -1)
{
nextlog = sitedb.Log.Store.Where(o => o.KeyHash == prelog.KeyHash && o.StoreNameHash == prelog.StoreNameHash).OrderByDescending().FirstOrDefault();
model.Id2 = nextlog.Id;
}
else
{
nextlog = sitedb.Log.Get(id2);
}
ISiteObject itemone = repo.GetByLog(prelog);
ISiteObject itemtwo = null;
if (nextlog.EditType != EditType.Delete)
{
itemtwo = repo.GetByLog(nextlog);
}
model.Title1 = itemone.Name;
model.Title2 = itemtwo != null ? itemtwo.Name : string.Empty;
if (itemone is Image)
{
string baseurl = call.WebSite.BaseUrl();
string url1 = (Sites.Systems.Routes.SystemRouteTemplate.Replace("{objecttype}", repo.ModelType.Name).Replace("{nameorid}", prelog.Id.ToString()));
string url2 = Sites.Systems.Routes.SystemRouteTemplate.Replace("{objecttype}", repo.ModelType.Name).Replace("{nameorid}", nextlog.Id.ToString());
model.DataType = VersionDataType.Image;
model.Source1 = Kooboo.Lib.Helper.UrlHelper.Combine(baseurl, url1);
model.Source2 = Kooboo.Lib.Helper.UrlHelper.Combine(baseurl, url2);
}
else
{
model.Source1 = Sites.Service.ObjectService.GetSummaryText(itemone);
model.Source2 = Sites.Service.ObjectService.GetSummaryText(itemtwo);
model.DataType = VersionDataType.String;
}
}
return(model);
}
public static void DefaultRender(FrontContext context, byte ConstType, string objectType, string NameOrId, Dictionary <string, string> Parameters)
{
var modeltype = Service.ConstTypeService.GetModelType(ConstType);
if (modeltype == null)
{
SpecialRender(context, ConstType, objectType, NameOrId, Parameters);
}
else
{
var repo = context.SiteDb.GetRepository(modeltype);
ISiteObject siteobject = null;
siteobject = repo?.GetByNameOrId(NameOrId) as ISiteObject;
if (siteobject == null)
{
long logid = -1;
if (long.TryParse(NameOrId, out logid))
{
var logentry = context.SiteDb.Log.Get(logid);
siteobject = repo.GetByLog(logentry) as ISiteObject;
}
}
if (siteobject != null)
{
var contenttype = Service.ConstTypeService.GetContentType(ConstType);
context.RenderContext.Response.ContentType = contenttype;
if (siteobject is ITextObject)
{
context.RenderContext.Response.ContentType += ";charset=utf-8";
var textobject = siteobject as ITextObject;
context.RenderContext.Response.Body = DataConstants.DefaultEncoding.GetBytes(textobject.Body);
}
else if (siteobject is IBinaryFile)
{
var binary = siteobject as IBinaryFile;
context.RenderContext.Response.Body = binary.ContentBytes;
}
else
{
context.RenderContext.Response.ContentType += ";charset=utf-8";
var json = Lib.Helper.JsonHelper.Serialize(siteobject);
context.RenderContext.Response.Body = DataConstants.DefaultEncoding.GetBytes(json);
}
}
}
}
public void AddOrUpdate(ISiteObject siteobject)
{
if (this.IndexType.Contains(siteobject.ConstType))
{
string meta = GetMetaKey(siteobject);
string body = GetBody(siteobject);
if (!string.IsNullOrWhiteSpace(body))
{
this.IndexData.AddOrUpdate(meta, body);
}
else
{
this.Delete(siteobject);
}
}
}
public static Sync.SyncObject ToSyncObject(ISiteObject SiteObject)
{
if (SiteObject == null)
{
return(null);
}
SyncObject SyncObj = new SyncObject();
SyncObj.ObjectId = SiteObject.Id;
SyncObj.ObjectConstType = SiteObject.ConstType;
SyncObj.JsonData = Lib.Helper.JsonHelper.Serialize(SiteObject);
return(SyncObj);
}
private static string GetRelatetionByType(SiteDb sitedb, ISiteObject item, byte type)
{
var relations = sitedb.Relations.GetReferredBy(item as SiteObject, type);
StringBuilder responseMessage = new StringBuilder();
foreach (var jitem in relations)
{
Guid id = jitem.objectXId;
string typeName = "";
var obj = GetSiteObject(sitedb, type, id, ref typeName);
if (obj != null)
{
//ToDo rewrite
var url = string.Format("/_Admin/Development/{2}?SiteId={0}&Id={1}", sitedb.Id, obj.Id, typeName);
responseMessage.AppendFormat("<a href='{0}' target='_blank'>{1}</a> ", url, obj.Name);
}
}
return(responseMessage.ToString());
}
public string SyncToDisk(SiteDb SiteDb, ISiteObject Value, ChangeType ChangeType, string StoreName)
{
if (Attributes.AttributeHelper.IsDiskable(Value) && !IsEmbedded(Value) && !string.IsNullOrEmpty(StoreName))
{
var value = Value as ISiteObject;
string relativeurl = DiskPathService.GetObjectRelativeUrl(value, SiteDb, StoreName);
if (!string.IsNullOrEmpty(relativeurl))
{
string fullpath = DiskPathService.GetFullDiskPath(SiteDb.WebSite, relativeurl);
if (ChangeType == ChangeType.Delete)
{
if (File.Exists(fullpath))
{
this.Delete(fullpath);
DiskSyncLog.DiskLogManager.Delete(fullpath, SiteDb.Id);
return(fullpath);
}
}
else
{
var coreobject = value as ICoreObject;
if (coreobject != null)
{
var contentbytes = DiskObjectConverter.ToBytes(SiteDb, value);
this.WriteBytes(fullpath, contentbytes);
DiskSyncLog.DiskLogManager.Add(fullpath, SiteDb.Id);
return(fullpath);
}
}
}
}
return(null);
}
public static DiskType GetDiskType(ISiteObject ModelItem)
{
var allattributes = ModelItem.GetType().GetCustomAttributes(false);
foreach (var item in allattributes)
{
if (item is Diskable)
{
var disktable = item as Diskable;
if (disktable.DiskType == DiskType.Binary)
{
if (ModelItem is IBinaryFile)
{
return(DiskType.Binary);
}
else
{
return(DiskType.Json);
}
}
if (disktable.DiskType == DiskType.Text)
{
if (ModelItem is ITextObject)
{
return(DiskType.Text);
}
else
{
return(DiskType.Json);
}
}
return(disktable.DiskType);
}
}
return(DiskType.Json);
}
public static string GetObjectRelativeUrl(ISiteObject siteobject, SiteDb sitedb, string StoreName = null)
{
if (siteobject == null)
{
return(null);
}
if (Attributes.AttributeHelper.IsRoutable(siteobject))
{
return(sitedb.Routes.GetObjectPrimaryRelativeUrl(siteobject.Id));
}
else
{
string typepath = string.IsNullOrEmpty(StoreName) ? siteobject.GetType().Name : StoreName;
string name = Attributes.AttributeHelper.IsNameAsId(siteobject) ? siteobject.Name : siteobject.Id.ToString();
string extension = DefaultExtension;
if (siteobject is IExtensionable)
{
var extensionboject = siteobject as IExtensionable;
if (!string.IsNullOrEmpty(extensionboject.Extension))
{
extension = extensionboject.Extension;
}
}
if (!extension.StartsWith("."))
{
extension = "." + extension;
}
if (!name.ToLower().EndsWith(extension))
{
name = name + extension;
}
return("/" + PathPrefix + "/" + typepath + "/" + name);
}
}
public CodeResult GetDisplayInfo(List <FindResult> finds, SiteDb sitedb, ISiteObject item)
{
CodeResult model = new CodeResult();
model.Id = item.Id;
var info = Kooboo.Sites.Service.ObjectService.GetObjectInfo(sitedb, item);
if (info != null)
{
model.Type = info.ModelType.Name;
model.Name = info.DisplayName;
model.Lines = finds;
// Edit URL.
model.Url = Kooboo.Sites.Service.ObjectService.GetEditRoute(item, sitedb);
}
else
{
model.Name = item.Name;
model.Lines = finds;
}
return(model);
}
public bool CheckAssignObject(ref ISiteObject SiteObject, byte[] DiskBytes)
{
var modeltype = SiteObject.GetType();
var SerializerType = Attributes.AttributeHelper.GetDiskType(modeltype);
if (SerializerType == Kooboo.Attributes.DiskType.Binary)
{
var binaryfile = SiteObject as IBinaryFile;
if (DiskBytes == null || IOHelper.IsEqualBytes(binaryfile.ContentBytes, DiskBytes))
{
return(false);
}
binaryfile.ContentBytes = DiskBytes;
}
else if (SerializerType == Kooboo.Attributes.DiskType.Text)
{
var textfile = SiteObject as ITextObject;
string textbody = System.Text.Encoding.UTF8.GetString(DiskBytes);
if (StringHelper.IsSameValue(textbody, textfile.Body))
{
return(false);
}
textfile.Body = textbody;
}
else
{
string fulltext = System.Text.Encoding.UTF8.GetString(DiskBytes);
var generatedbody = Lib.Helper.JsonHelper.Serialize(SiteObject);
if (StringHelper.IsSameValue(generatedbody, fulltext))
{
return(false);
}
SiteObject = JsonHelper.Deserialize(fulltext, modeltype) as ISiteObject;
}
return(true);
}
public static ObjectInfo GetObjectInfo(SiteDb SiteDb, ISiteObject siteobject)
{
if (siteobject == null)
{
return(null);
}
ObjectInfo info = new ObjectInfo();
info.ObjectId = siteobject.Id;
info.ConstType = siteobject.ConstType;
if (info.ConstType > 0)
{
info.ModelType = ConstTypeService.GetModelType(siteobject.ConstType);
}
if (info.ModelType == null)
{
info.ModelType = siteobject.GetType();
}
if (siteobject is IBinaryFile)
{
info.Size = ((IBinaryFile)siteobject).Size;
}
else if (siteobject is ITextObject)
{
info.Size = (((ITextObject)siteobject).Body ?? "").Length;
}
if (Kooboo.Lib.Reflection.TypeHelper.HasInterface(info.ModelType, typeof(IEmbeddable)))
{
var embeddable = siteobject as IEmbeddable;
if (embeddable.IsEmbedded)
{
return(GetObjectInfo(SiteDb, embeddable.OwnerObjectId, embeddable.OwnerConstType));
}
}
if (Kooboo.Sites.Service.ObjectService.IsRoutable(siteobject, false))
{
info.Url = GetObjectRelativeUrl(SiteDb, siteobject as SiteObject);
info.DisplayName = info.Url;
info.Name = siteobject.Name;
return(info);
}
else
{
if (info.ModelType == typeof(CmsCssRule))
{
var rule = siteobject as CmsCssRule;
if (rule == null)
{
return(null);
}
if (rule.IsInline)
{
return(GetObjectInfo(SiteDb, rule.OwnerObjectId, rule.OwnerObjectConstType));
}
else
{
return(GetObjectInfo(SiteDb, rule.ParentStyleId, ConstObjectType.Style));
}
}
info.Url = "/__kb/" + info.ModelType.Name + "/" + info.ObjectId.ToString();
info.DisplayName = siteobject.Name;
info.Name = siteobject.Name;
if (info.ModelType == typeof(TextContent))
{
info.Name = Kooboo.Sites.Helper.ContentHelper.GetSummary(siteobject as TextContent, SiteDb.WebSite.DefaultCulture);
info.DisplayName = info.Name;
}
if (info.ModelType == typeof(DataMethodSetting))
{
var datamethod = siteobject as DataMethodSetting;
if (datamethod != null)
{
info.Name = datamethod.OriginalMethodName;
info.DisplayName = datamethod.OriginalMethodName;
}
}
return(info);
}
}
public static string SyncToDisk(SiteDb SiteDb, ISiteObject Value, ChangeType ChangeType, string StoreName)
{
var manager = new SyncManager(SiteDb.WebSite.Id);
return(manager.SyncToDisk(SiteDb, Value, ChangeType, StoreName));
}
public static bool IsRoutable(ISiteObject item, bool IncludeCode = true)
{
return(IsRoutable(item.GetType(), IncludeCode));
}
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);
}
}
}
}
}
}
}
internal string GetMetaKey(ISiteObject siteobject)
{
string metaname = Service.ConstTypeService.GetModelType(siteobject.ConstType).Name;
return(new MetaIndex(metaname, siteobject.Id).ToString());
}
private bool ShouldIndex(ISiteObject siteobject)
{
return(this.IndexType.Contains(siteobject.ConstType));
}
