private static void IndexItem(GroupTopic groupTopic)
{
if (WebConfigSettings.DisableSearchIndex)
{
return;
}
//SiteSettings siteSettings = CacheHelper.GetCurrentSiteSettings();
//if (siteSettings == null)
//{
// if (log.IsErrorEnabled)
// {
// log.Error("siteSettings object retrieved in GroupTopicIndexBuilderProvider.IndexItem was null");
// }
// return;
//}
if (groupTopic == null)
{
if (log.IsErrorEnabled)
{
log.Error("groupTopic object passed in GroupTopicIndexBuilderProvider.IndexItem was null");
}
return;
}
Group group = new Group(groupTopic.GroupId);
Module module = new Module(group.ModuleId);
Guid groupFeatureGuid = new Guid("E75BAF8C-7079-4d10-A122-1AA3624E26F2");
ModuleDefinition groupFeature = new ModuleDefinition(groupFeatureGuid);
// get list of pages where this module is published
List <PageModule> pageModules
= PageModule.GetPageModulesByModule(group.ModuleId);
// must update index for all pages containing
// this module
foreach (PageModule pageModule in pageModules)
{
PageSettings pageSettings
= new PageSettings(
groupTopic.SiteId,
pageModule.PageId);
//don't index pending/unpublished pages
if (pageSettings.IsPending)
{
continue;
}
IndexItem indexItem = new IndexItem();
if (groupTopic.SearchIndexPath.Length > 0)
{
indexItem.IndexPath = groupTopic.SearchIndexPath;
}
indexItem.SiteId = groupTopic.SiteId;
indexItem.PageId = pageModule.PageId;
indexItem.PageName = pageSettings.PageName;
// permissions are kept in sync in search index
// so that results are filtered by role correctly
indexItem.ViewRoles = pageSettings.AuthorizedRoles;
indexItem.ModuleViewRoles = module.ViewRoles;
indexItem.ItemId = groupTopic.GroupId;
indexItem.ModuleId = group.ModuleId;
indexItem.ModuleTitle = module.ModuleTitle;
indexItem.ViewPage = "Groups/Topic.aspx";
indexItem.QueryStringAddendum = "&topic="
+ groupTopic.TopicId.ToString()
+ "&postid=" + groupTopic.PostId.ToString();
indexItem.FeatureId = groupFeatureGuid.ToString();
indexItem.FeatureName = groupFeature.FeatureName;
indexItem.FeatureResourceFile = groupFeature.ResourceFile;
indexItem.Title = groupTopic.Subject;
indexItem.Content = groupTopic.PostMessage;
indexItem.PublishBeginDate = pageModule.PublishBeginDate;
indexItem.PublishEndDate = pageModule.PublishEndDate;
IndexHelper.RebuildIndex(indexItem);
if (log.IsDebugEnabled)
{
log.Debug("Indexed "
+ groupTopic.Subject);
}
}
}
/// <summary>
/// Gets the insert position.
/// </summary>
/// <param name="searchItem">The search item.</param>
/// <param name="sortBy">The sort by.</param>
/// <param name="comparer">The comparer.</param>
/// <returns>InsertPosition</returns>
internal int GetInsertPosition(IndexItem searchItem, SortBy sortBy, InternalItemComparer comparer)
{
return(InternalItemList.GetInsertPosition(InternalItemAdapter.ConvertToInternalItem(searchItem), comparer, sortBy));
}
private void AddMapForOffset(IndexItem offset)
{
if (IndexType == IndexListType.Chromatogram)
{
return;
}
OffsetsMapNative.Add(offset.Ref, offset.Offset);
// This won't be sufficient until there is a valid parser for all forms of NativeID.
// Using artificial scan number for now.
OffsetsMapInt.Add(offset.IdNum, offset.Offset);
IdToNativeMap.Add(offset.IdNum, offset.Ref);
NativeToIdMap.Add(offset.Ref, offset.IdNum);
/*if (IndexType == IndexListType.Spectrum)
{
long id = Int64.Parse(offset.Ref.Substring(offset.Ref.LastIndexOfAny(new char[] {'=', 'F'}) + 1));
OffsetsMapInt.Add(id, offset.Offset);
IdNativeMap.Add(id, offset.Ref);
offset.IdNum = id;
}*/
}
/// <summary> Indexes the item. </summary>
/// <param name="reservationEvent"> The reservation event. </param>
private static void IndexItem(ReservationEvent reservationEvent)
{
if (WebConfigSettings.DisableSearchIndex || reservationEvent == null)
{
return;
}
try
{
var module = new Module(reservationEvent.ModuleId);
var reservationFeature = new ModuleDefinition(reservationFeatureGuid);
// get list of pages where this module is published
var pageModules = PageModule.GetPageModulesByModule(reservationEvent.ModuleId);
foreach (var pageModule in pageModules)
{
var pageSettings = new PageSettings(reservationEvent.SiteId, pageModule.PageId);
//don't index pending/unpublished pages
if (pageSettings.IsPending)
{
continue;
}
var indexItem = new IndexItem
{
SiteId = reservationEvent.SiteId,
PageId = pageSettings.PageId,
PageName = pageSettings.PageName,
ViewRoles = pageSettings.AuthorizedRoles,
ModuleViewRoles = module.ViewRoles,
ItemId = reservationEvent.ItemId,
ModuleId = reservationEvent.ModuleId,
ViewPage = "Reservation/Details.aspx",
FeatureId = reservationFeatureGuid.ToString(),
FeatureName = reservationFeature.FeatureName,
FeatureResourceFile = reservationFeature.ResourceFile,
ModuleTitle = module.ModuleTitle,
Title = reservationEvent.Title,
Content = reservationEvent.Description,
PublishBeginDate = pageModule.PublishBeginDate,
PublishEndDate = pageModule.PublishEndDate,
CreatedUtc = reservationEvent.CreatedDate,
LastModUtc = reservationEvent.LastModUtc
};
if (reservationEvent.SearchIndexPath.Length > 0)
{
indexItem.IndexPath = reservationEvent.SearchIndexPath;
}
IndexHelper.RebuildIndex(indexItem);
}
if (Log.IsDebugEnabled)
{
Log.Debug("Indexed " + reservationEvent.Title);
}
}
catch (System.Data.Common.DbException ex)
{
Log.Error("ReservationEventIndexBuilderProvider.IndexItem", ex);
}
}
private void MetodMinElement()
{
List <Index> indexesFalseTable = new List <Index>();
int[] indexNullI = new int[m * n];
int[] indexNullJ = new int[m * n];
gridDelta.RowCount = 0;
C = new Element[n, m];
El[] CC = new El[n * m];
PivotN = -1;
PivotM = -1;
int i = 0;
int j = 0;
//сохраняем значения
for (i = 0; i < aSupply.Length; i++)
{
aSupply[i] = Convert.ToInt32(gridA.Rows[i].Cells[0].Value);
}
for (j = 0; j < aDemand.Length; j++)
{
aDemand[j] = Convert.ToInt32(gridB.Rows[j].Cells[0].Value);
}
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
C[i, j].Index = Convert.ToInt32(gridC.Rows[i].Cells[j].Value);
}
}
//сохраняем тарифы и их индексы
int l = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
CC[l].Index = C[i, j].Index;
CC[l].IndexI = i;
CC[l].IndexJ = j;
l++;
}
}
//сортируем по тарифам (индексам)
l = 0;
foreach (var p in CC.OrderBy(itm => itm.Index))
{
CC[l] = p;
l++;
}
l = 0;
int minEl = 0;
while (l < n * m)
{
if (CC[l].Index != 0)
{
minEl = Element.FindMinElement(aSupply[CC[l].IndexI], aDemand[CC[l].IndexJ]);
C[CC[l].IndexI, CC[l].IndexJ].Value = minEl;
if ((aSupply[CC[l].IndexI] - minEl == 0 && aDemand[CC[l].IndexJ] - minEl == 0) && (aSupply[CC[l].IndexI] != 0 && aDemand[CC[l].IndexJ] != 0))
{
indexesFalseTable.Add(new Index {
I = CC[l].IndexI, J = CC[l].IndexJ
});
}
aSupply[CC[l].IndexI] -= minEl;
aDemand[CC[l].IndexJ] -= minEl;
}
l++;
}
l = 0;
while (l < n * m)
{
if (CC[l].Index == 0)
{
minEl = Element.FindMinElement(aSupply[CC[l].IndexI], aDemand[CC[l].IndexJ]);
C[CC[l].IndexI, CC[l].IndexJ].Value = minEl;
aSupply[CC[l].IndexI] -= C[CC[l].IndexI, CC[l].IndexJ].Value;
aDemand[CC[l].IndexJ] -= C[CC[l].IndexI, CC[l].IndexJ].Value;
}
l++;
}
int s = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < m; j++)
{
if (C[i, j].Value != 0)
{
s++;
}
}
}
//ложный ноль
IndexItem[] arr = new IndexItem[] { };
IndexItem itemToRemove = new IndexItem {
};
foreach (Index indexes in indexesFalseTable)
{
if (s < n + m - 1)
{
if (indexes.I + 1 >= n)
{
if (indexes.J + 1 >= m)
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J - 1], I = indexes.I, J = indexes.J - 1
},
new IndexItem {
Item = C[indexes.I - 1, indexes.J], I = indexes.I - 1, J = indexes.J
}
};
}
else if (indexes.J - 1 <= 0)
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J + 1], I = indexes.I, J = indexes.J + 1
},
new IndexItem {
Item = C[indexes.I - 1, indexes.J], I = indexes.I - 1, J = indexes.J
}
};
}
else
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J + 1], I = indexes.I, J = indexes.J + 1
},
new IndexItem {
Item = C[indexes.I, indexes.J - 1], I = indexes.I, J = indexes.J - 1
},
new IndexItem {
Item = C[indexes.I - 1, indexes.J], I = indexes.I - 1, J = indexes.J
}
};
}
}
if (indexes.I - 1 <= 0)
{
if (indexes.J + 1 >= m)
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J - 1], I = indexes.I, J = indexes.J - 1
},
new IndexItem {
Item = C[indexes.I + 1, indexes.J], I = indexes.I + 1, J = indexes.J
}
};
}
else if (indexes.J - 1 <= 0)
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J + 1], I = indexes.I, J = indexes.J + 1
},
new IndexItem {
Item = C[indexes.I + 1, indexes.J], I = indexes.I + 1, J = indexes.J
}
};
}
else
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J + 1], I = indexes.I, J = indexes.J + 1
},
new IndexItem {
Item = C[indexes.I, indexes.J - 1], I = indexes.I, J = indexes.J - 1
},
new IndexItem {
Item = C[indexes.I + 1, indexes.J], I = indexes.I + 1, J = indexes.J
}
};
}
}
if (indexes.I - 1 >= 0 && indexes.I + 1 <= n)
{
if (indexes.J + 1 >= m)
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J - 1], I = indexes.I, J = indexes.J - 1
},
new IndexItem {
Item = C[indexes.I + 1, indexes.J], I = indexes.I + 1, J = indexes.J
},
new IndexItem {
Item = C[indexes.I - 1, indexes.J], I = indexes.I - 1, J = indexes.J
}
};
}
else if (indexes.J - 1 <= 0)
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J + 1], I = indexes.I, J = indexes.J + 1
},
new IndexItem {
Item = C[indexes.I + 1, indexes.J], I = indexes.I + 1, J = indexes.J
},
new IndexItem {
Item = C[indexes.I - 1, indexes.J], I = indexes.I - 1, J = indexes.J
}
};
}
else
{
arr = new IndexItem[] {
new IndexItem {
Item = C[indexes.I, indexes.J + 1], I = indexes.I, J = indexes.J + 1
},
new IndexItem {
Item = C[indexes.I, indexes.J - 1], I = indexes.I, J = indexes.J - 1
},
new IndexItem {
Item = C[indexes.I + 1, indexes.J], I = indexes.I + 1, J = indexes.J
},
new IndexItem {
Item = C[indexes.I - 1, indexes.J], I = indexes.I - 1, J = indexes.J
}
};
}
}
int indI = -1;
int indJ = -1;
int minInd = int.MaxValue;
foreach (IndexItem item in arr)
{
if (item.Item.Index <= minInd && item.Item.Value == 0 && item.Item.Value != -1)
{
minInd = item.Item.Index;
indI = item.I;
indJ = item.J;
}
}
if (indI >= 0 && indJ >= 0)
{
C[indI, indJ].Value = -1;
}
}
s++;
}
//PrintPlan();
//printZ();
}
public override object Execute(List <string> args)
{
var blamCache = BlamCache;
int zoneSetIndex = -1;
BspFlags bspMask = 0;
MultiplayerScenarioConversionFlags conversionFlags;
var firstNonFlagArgumentIndex = ParseConversionFlags(args, out conversionFlags);
args = args.Skip(firstNonFlagArgumentIndex).ToList();
IndexItem blamScnrTag = BlamCache.IndexItems.First(x => x.GroupTag == "scnr");
var blamScnr = BlamCache.Deserializer.Deserialize <Scenario>(
new CacheSerializationContext(ref blamCache, blamScnrTag));
if (args.Count < 1)
{
Dictionary <string, int> structureBspsByName = new Dictionary <string, int>();
Dictionary <string, int> zoneSetsByName = new Dictionary <string, int>();
Console.WriteLine("-----------------------------------------");
for (int i = 0; i < blamScnr.ZoneSets.Count; i++)
{
Console.WriteLine($"{i}. {blamCache.Strings.GetString(blamScnr.ZoneSets[i].Name)}");
}
Console.WriteLine("-----------------------------------------");
Console.WriteLine("Enter the name or index of the zone set to use:");
string zoneSetName = Console.ReadLine().Trim();
for (int i = 0; i < blamScnr.StructureBsps.Count; i++)
{
structureBspsByName.Add(blamScnr.StructureBsps[i].StructureBsp.Name, i);
}
if (zoneSetsByName.ContainsKey(zoneSetName))
{
zoneSetIndex = zoneSetsByName[zoneSetName];
}
else
{
if (!int.TryParse(zoneSetName, out zoneSetIndex))
{
zoneSetIndex = -1;
}
}
if (zoneSetIndex == -1)
{
Console.WriteLine($"Zone set '{zoneSetName}' could not be found!\n");
return(true);
}
var zoneSet = blamScnr.ZoneSets[zoneSetIndex];
Console.WriteLine("-----------------------------------------");
for (int i = 0; i < 32; i++)
{
if ((zoneSet.LoadedBsps & (BspFlags)(1u << i)) != 0)
{
Console.WriteLine($"{i}. {blamScnr.StructureBsps[i].StructureBsp.Name}");
}
}
Console.WriteLine("-----------------------------------------");
Console.WriteLine("Enter the name or index of each bsp to include on a new line followed by a blank line:");
for (string line; !string.IsNullOrWhiteSpace(line = Console.ReadLine());)
{
var sbspName = line.Trim();
int bspIndex = -1;
if (structureBspsByName.ContainsKey(sbspName))
{
bspIndex = structureBspsByName[sbspName];
}
else
{
if (!int.TryParse(sbspName, out bspIndex))
{
bspIndex = -1;
}
}
if (bspIndex == -1)
{
Console.WriteLine($"Could not find bsp '{sbspName}'");
}
bspMask |= (BspFlags)(1u << bspIndex);
}
}
else
{
var tagName = args[0].Trim();
var bspIndex = blamScnr.StructureBsps.FindIndex(x => x.StructureBsp.Name == tagName);
if (bspIndex == -1)
{
Console.WriteLine($"Could not find bsp '{tagName}'");
return(true);
}
bspMask = (BspFlags)(1u << bspIndex);
for (int i = 0; i < blamScnr.ZoneSets.Count; i++)
{
if ((blamScnr.ZoneSets[i].LoadedBsps & bspMask) != 0)
{
zoneSetIndex = i;
break;
}
}
if (zoneSetIndex == -1)
{
Console.WriteLine($"No zone set includes bsp '{tagName}'!");
return(true);
}
}
Console.WriteLine("Converting...");
Convert(zoneSetIndex, bspMask, conversionFlags);
return(true);
}
public override int HandleMap(IndexItem indexItem, IEnumerable mapResults, IndexWriteOperation writer, TransactionOperationContext indexContext, IndexingStatsScope stats)
{
throw new NotSupportedException($"Index {Name} is in-memory implementation of a faulty index", _e);
}
public IndexTable(CacheBase Cache)
{
cache = Cache;
var IH = cache.IndexHeader;
var CH = cache.Header;
var Reader = cache.Reader;
#region Read Tags' Info
ClassList = new List<TagClass>();
var classDic = new Dictionary<string, int>();
int[] sbspOffset = new int[0];
int[] sbspMagic = new int[0];
int[] sbspID = new int[0];
int[] indices = new int[IH.tagCount];
Reader.SeekTo(IH.tagInfoOffset);
for (int i = 0; i < IH.tagCount; i++)
{
var cname = Reader.ReadString(4);
if (Reader.EndianType == EndianFormat.LittleEndian)
{
var tname = cname.ToCharArray();
Array.Reverse(tname);
cname = new string(tname);
}
int index;
if (!classDic.TryGetValue(cname, out index))
{
index = classDic.Count;
classDic.Add(cname, classDic.Count);
}
Reader.Skip(8); //parent classes
IndexItem item = new IndexItem() { Cache = cache };
item.ClassIndex = index;
item.ID = Reader.ReadInt32();
indices[i] = Reader.ReadInt32() - CH.Magic - CH.fileTableOffset;
item.Offset = Reader.ReadInt32() - CH.Magic;
this.Add(item);
Reader.Skip(8); //empty?
if (cname == "scnr")
{
long tempOffset = Reader.Position;
Reader.SeekTo(item.Offset + 1444);
int jCount = Reader.ReadInt32();
int jOffset = Reader.ReadInt32() - cache.Magic;
sbspOffset = new int[jCount];
sbspMagic = new int[jCount];
sbspID = new int[jCount];
for (int j = 0; j < jCount; j++)
{
Reader.SeekTo(jOffset + j * 32);
sbspOffset[j] = Reader.ReadInt32();
Reader.ReadInt32();
sbspMagic[j] = Reader.ReadInt32() - sbspOffset[j];
Reader.SeekTo(jOffset + j * 32 + 28);
sbspID[j] = Reader.ReadInt32();
}
Reader.SeekTo(tempOffset);
}
}
for (int i = 0; i < sbspID.Length; i++)
{
var tag = GetItemByID(sbspID[i]);
tag.Offset = sbspOffset[i];
tag.Magic = sbspMagic[i];
}
CH.fileTableSize = this[0].Offset - CH.fileTableOffset;
foreach (var pair in classDic)
ClassList.Add(new TagClass() { ClassCode = pair.Key });
#endregion
#region Read Names
Reader.StreamOrigin = CH.fileTableOffset;
for (int i = 0; i < indices.Length; i++)
{
if (indices[i] == -1)
{
this[i].Filename = "<null>";
continue;
}
Reader.SeekTo(indices[i]);
int length;
if (i == indices.Length - 1)
length = CH.fileTableSize - indices[i];
else
{
if (indices[i + 1] == -1)
{
int index = -1;
for (int j = i + 1; j < indices.Length; j++)
{
if (indices[j] != -1)
{
index = j;
break;
}
}
length = (index == -1) ? CH.fileTableSize - indices[i] : indices[index] - indices[i];
}
else
length = indices[i + 1] - indices[i];
}
if (length <= 1)
{
this[i].Filename = this[i].Offset.ToString("X8");
continue;
}
this[i].Filename = Reader.ReadNullTerminatedString(length);
}
Reader.StreamOrigin = 0;
#endregion
}
/// <summary>
/// Processes files packed as type 2 (encrypted & compressed)
/// </summary>
/// <param name="packFilePath">Path to EPK file (name included)</param>
/// <param name="saveFilesPath">Path to where the file should be saved (name not included)</param>
/// <param name="item">Item from deserialized list</param>
/// <param name="packKey">Pack XTEA key</param>
/// <param name="hashMismatchFiles">Vector holding files with CRC mismatch</param>
/// <param name="errorFiles">Vector holding files ignored</param>
/// <returns></returns>
public static int ProcessFileType2(string packFilePath, string saveFilesPath, IndexItem item, byte[] packKey, Action<ErrorItem, string> fileLoggingCallback)
{
int valueToReturn = 0;
byte[] fileHeaderBuffer = IOHelper.ReadFileOffsetToLength(packFilePath, item.Offset, 16);
// Read FourCC value
var fourCc = new byte[4];
Array.Copy(fileHeaderBuffer, 0, fourCc, 0, 4);
// Get sizes from header
int encryptedSize = IOHelper.ReadIntFromArray(fileHeaderBuffer, 4, 4);
int compressedSize = IOHelper.ReadIntFromArray(fileHeaderBuffer, 8, 4);
int decompressedSize = IOHelper.ReadIntFromArray(fileHeaderBuffer, 12, 4);
if (encryptedSize <= 0 || compressedSize <= 0 || decompressedSize <= 0)
{
fileLoggingCallback(new ErrorItem(item.Filename, "Invalid encrypted/compressed/decompressed size."), null);
return 2;
}
#region Cap Check
if (encryptedSize > 629145600)
{
fileLoggingCallback(new ErrorItem(item.Filename,
String.Format("Max memory allocation reached, tried to allocate: {0} mb",
Math.Round(encryptedSize / 1024.0 / 1024.0, 2))), null);
return 2;
}
if (compressedSize > 629145600)
{
fileLoggingCallback(new ErrorItem(item.Filename,
String.Format("Max memory allocation reached, tried to allocate: {0} mb",
Math.Round(encryptedSize / 1024.0 / 1024.0, 2))), null);
return 2;
}
if (decompressedSize > 629145600)
{
fileLoggingCallback(new ErrorItem(item.Filename,
String.Format("Max memory allocation reached, tried to allocate: {0} mb",
Math.Round(encryptedSize / 1024.0 / 1024.0, 2))), null);
return 2;
}
#endregion
// Is header correct?
if (!fourCc.SequenceEqual(ConstantsBase.LzoFourCc))
{
// Show error msg and cancel operation
// AppLog.SendMessage(8, item.Filename, item.ParentFile); TODO
fileLoggingCallback(new ErrorItem(item.Filename, String.Format("Invalid FourCC: {0}. Expected: {1} ({2})",
BitConverter.ToString(fourCc),
BitConverter.ToString(ConstantsBase.LzoFourCc),
Encoding.ASCII.GetString(ConstantsBase.LzoFourCc))),
"");
return 2;
}
// Get actual data
byte[] rawDataBuffer = IOHelper.ReadFileOffsetToLength(packFilePath, item.Offset + 16, encryptedSize);
// Take care of relative path and folders
string path = DrivePointManager.RemoveDrivePoints((saveFilesPath + item.Filename).Replace("\\", "/"));
// uh, I've found a bug. This should be changed... The program now detects new drive points, for example
string foldersPath = path.Substring(0, path.LastIndexOf("/", StringComparison.Ordinal));
// Check if paths exist
Directory.CreateDirectory(foldersPath);
// Overwrite file TODO SAME AS TYPE 2
if (File.Exists(path))
{
if (IOHelper.IsFileLocked(path))
{
//WindowLog.LogOutputMessage(Log.LogId.FILE_OPENED_BY_EXTERNAL_PROCESS_LOG, args: path); TODO
return 2;
}
File.Delete(path);
}
// Create encryption and encryption without header buffers
var decryptedBuffer = new byte[encryptedSize];
var decryptedBufferWithoutHeader = new byte[encryptedSize - 4];
// It should never return false
if (Xtea.Decrypt(packKey, rawDataBuffer, decryptedBuffer, (uint)encryptedSize) == false)
{
throw new Exception("INTERNAL ERROR - DECRYPTION FAILED");
}
// Get header after decryption
var headerAfterDecryption = new byte[4];
Array.Copy(decryptedBuffer, 0, headerAfterDecryption, 0, 4);
// Was the encryption key correct?
if (!headerAfterDecryption.SequenceEqual(ConstantsBase.LzoFourCc))
{
// Send message and return error
//WindowLog.LogOutputMessage(Log.LogId.DECRYPTION_FAILED_LOG, args: item.Filename); TODO
fileLoggingCallback(new ErrorItem(item.Filename, String.Format("Invalid header after decryption: {0}. Expected: {1} ({2})",
BitConverter.ToString(fourCc),
BitConverter.ToString(ConstantsBase.LzoFourCc),
Encoding.ASCII.GetString(ConstantsBase.LzoFourCc))),
"");
valueToReturn = 2;
}
// Get actual decrypted data
Array.Copy(decryptedBuffer, 4, decryptedBufferWithoutHeader, 0, decryptedBuffer.Length - 4);
// Check hash
if (!CompareCrcHashes(decryptedBufferWithoutHeader, item.CRCHash))
{
// Log CRC mismatch
// AppLog.SendMessage(2, item.Filename);
fileLoggingCallback(null, item.Filename);
valueToReturn = 1;
}
byte[] decompressedData = LzoHelper.DecompressData(decompressedSize, compressedSize, decryptedBufferWithoutHeader);
// Write file
File.WriteAllBytes(path, decompressedData);
return valueToReturn;
}
/// <summary>
///
/// </summary>
/// <param name="packFilePath"></param>
/// <param name="saveFilesPath"></param>
/// <param name="item"></param>
/// <param name="packKey"></param>
/// <param name="fileLoggingCallback"></param>
/// <returns></returns>
public static int ProcessFileType3(string packFilePath, string saveFilesPath, IndexItem item, byte[] packKey,
Action<ErrorItem, string> fileLoggingCallback)
{
return 0;
}
/// <summary>
/// Processes files packed as type 1 (LZO compressed)
/// </summary>
/// <param name="packFilePath">Path to EPK file (name included)</param>
/// <param name="saveFilesPath">Path to where the file should be saved (name not included)</param>
/// <param name="item">Item from deserialized list</param>
/// <param name="hashMismatchFiles">Vector holding files with CRC mismatch</param>
/// <param name="errorFiles">Vector holding files ignored</param>
/// <returns></returns>
public static int ProcessFileType1(string packFilePath, string saveFilesPath, IndexItem item, Action<ErrorItem, string> fileLoggingCallback)
{
int valueToReturn = 0;
byte[] fileHeaderBuffer = IOHelper.ReadFileOffsetToLength(packFilePath, item.Offset, 16);
// Read FourCC value
byte[] fourCC = new byte[4];
Array.Copy(fileHeaderBuffer, 0, fourCC, 0, 4);
// Get sizes from header
int encryptedSize = IOHelper.ReadIntFromArray(fileHeaderBuffer, 4, 4);
int compressedSize = IOHelper.ReadIntFromArray(fileHeaderBuffer, 8, 4);
int decompressedSize = IOHelper.ReadIntFromArray(fileHeaderBuffer, 12, 4);
// Compare FourCC header
if (!fourCC.SequenceEqual(ConstantsBase.LzoFourCc))
{
fileLoggingCallback(new ErrorItem(item.Filename, String.Format("Invalid FourCC: {0}. Expected: {1} ({2})",
BitConverter.ToString(fourCC),
BitConverter.ToString(ConstantsBase.LzoFourCc),
Encoding.ASCII.GetString(ConstantsBase.LzoFourCc))),
"");
return 2;
}
if (encryptedSize != 0 || compressedSize <= 0 || decompressedSize <= 0)
{
fileLoggingCallback(new ErrorItem(item.Filename, String.Format("Invalid header sizes (enc: {0} / cmpr: {1} / decompr: {2}", encryptedSize, compressedSize, decompressedSize)), "");
return 2;
}
// Sizes capped at 629145600
#region Cap Check
if (encryptedSize > 629145600)
{
fileLoggingCallback(new ErrorItem(item.Filename,
String.Format("Max memory allocation reached, tried to allocate: {0} mb",
Math.Round(encryptedSize / 1024.0 / 1024.0, 2))), null);
return 2;
}
if (compressedSize > 629145600)
{
fileLoggingCallback(new ErrorItem(item.Filename,
String.Format("Max memory allocation reached, tried to allocate: {0} mb",
Math.Round(compressedSize / 1024.0 / 1024.0, 2))), null);
return 2;
}
if (decompressedSize > 629145600)
{
fileLoggingCallback(new ErrorItem(item.Filename,
String.Format("Max memory allocation reached, tried to allocate: {0} mb",
Math.Round(decompressedSize / 1024.0 / 1024.0, 2))), null);
return 2;
}
#endregion
// Take care of relative path and folders
string path = DrivePointManager.RemoveDrivePoints((saveFilesPath + item.Filename).Replace("\\", "/"));
string foldersPath = path.Substring(0, path.LastIndexOf("/", StringComparison.Ordinal));
// Get actual data
byte[] rawFileBuffer = IOHelper.ReadFileOffsetToLength(packFilePath, item.Offset + 20, compressedSize);
// Target directory exists?
Directory.CreateDirectory(foldersPath);
// Overwrite file TODO SAME AS TYPE 2
if (File.Exists(path))
{
if (IOHelper.IsFileLocked(path))
{
//WindowLog.LogOutputMessage(Log.LogId.FILE_OPENED_BY_EXTERNAL_PROCESS_LOG, args: path); TODO
return 2;
}
File.Delete(path);
}
// Decompress data
byte[] decompressedDataBuffer = LzoHelper.DecompressData(decompressedSize, compressedSize, rawFileBuffer);
// Check hash
if (!CompareCrcHashes(decompressedDataBuffer, item.CRCHash))
{
// Log CRC mismatch
fileLoggingCallback(null, item.Filename);
valueToReturn = 1;
}
// Write file to disk
File.WriteAllBytes(path, decompressedDataBuffer);
return valueToReturn;
}
/// <summary>
/// Processes files packed as type 0 (packed)
/// </summary>
/// <param name="packFilePath">Path to EPK file (name included)</param>
/// <param name="saveFilesPath">Path to where the file should be saved (name not included)</param>
/// <param name="item">Item from deserialized list</param>
/// <param name="hashMismatchFiles">Vector holding files with CRC mismatch</param>
/// <param name="errorFiles">Vector holding files ignored</param>
/// <returns></returns>
public static int ProcessFileType0(string packFilePath, string saveFilesPath, IndexItem item, Action<ErrorItem, string> fileLoggingCallback)
{
int valueToReturn = 0;
byte[] rawFileBuffer = IOHelper.ReadFileOffsetToLength(packFilePath, item.Offset, item.Size);
string path = DrivePointManager.RemoveDrivePoints((saveFilesPath + item.Filename).Replace("\\", "/"));
string foldersPath = path.Substring(0, path.LastIndexOf("/", StringComparison.Ordinal));
//Does the target directory exist?
Directory.CreateDirectory(foldersPath);
// Overwrite file TODO SAME AS TYPE 2
if (File.Exists(path))
{
if (IOHelper.IsFileLocked(path))
{
//WindowLog.LogOutputMessage(Log.LogId.FILE_OPENED_BY_EXTERNAL_PROCESS_LOG, args: path); TODO
return 2;
}
File.Delete(path);
}
//Check hashes
if (!CompareCrcHashes(rawFileBuffer, item.CRCHash))
{
//Log CRC mismatch
fileLoggingCallback(null, item.Filename);
valueToReturn = 1;
}
//Write file to disk
File.WriteAllBytes(path, rawFileBuffer);
return valueToReturn;
}
public IndexTable(CacheFile cache)
{
Clear();
var IH = cache.IndexHeader;
var CH = cache.Header;
var reader = cache.Reader;
ClassList = new List <TagClass>();
var classDic = new Dictionary <string, int>();
var sbspOffset = new int[0];
var sbspMagic = new int[0];
var sbspID = new int[0];
reader.SeekTo(IH.TagsOffset);
for (int i = 0; i < IH.TagCount; i++)
{
var cname = reader.ReadString(4);
var tname = cname.ToCharArray();
Array.Reverse(tname);
cname = new string(tname);
if (!classDic.TryGetValue(cname, out int index))
{
index = classDic.Count;
classDic.Add(cname, classDic.Count);
}
var item = new IndexItem
{
Cache = cache,
ClassIndex = index,
ID = reader.ReadInt32(),
Offset = reader.ReadInt32(),
Size = reader.ReadInt32()
};
if (item.Offset == 0 || item.ID == -1)
{
item.External = true;
}
else
{
item.Offset -= cache.Magic;
}
Add(item);
if (cname == "scnr" && cache.Version < CacheVersion.Halo2Vista)
{
long tempOffset = reader.Position;
reader.SeekTo(item.Offset + 528);
int jCount = reader.ReadInt32();
int jOffset = reader.ReadInt32() - cache.Magic;
sbspOffset = new int[jCount];
sbspMagic = new int[jCount];
sbspID = new int[jCount];
for (int j = 0; j < jCount; j++)
{
reader.SeekTo(jOffset + j * 68);
sbspOffset[j] = reader.ReadInt32();
reader.ReadInt32();
sbspMagic[j] = reader.ReadInt32() - sbspOffset[j];
reader.SeekTo(jOffset + j * 68 + 20);
sbspID[j] = reader.ReadInt32();
}
reader.SeekTo(tempOffset);
}
}
foreach (var pair in classDic)
{
ClassList.Add(new TagClass()
{
ClassCode = pair.Key
});
}
#region Read Indices
reader.SeekTo(CH.TagNamesIndicesOffset);
var offsets = new int[IH.TagCount];
for (int i = 0; i < IH.TagCount; i++)
{
offsets[i] = reader.ReadInt32();
}
#endregion
#region Read Names
reader.StreamOrigin = CH.TagNamesBufferOffset;
for (int i = 0; i < offsets.Length; i++)
{
this[i].Name = null;
if (offsets[i] == -1)
{
continue;
}
reader.SeekTo(offsets[i]);
var name = "";
for (char c; (c = reader.ReadChar()) != '\0'; name += c)
{
;
}
if (name.Length > 0)
{
this[i].Name = name;
}
}
reader.StreamOrigin = 0;
#endregion
}
public override void RebuildIndex(
PageSettings pageSettings,
string indexPath)
{
if (WebConfigSettings.DisableSearchIndex)
{
return;
}
if (pageSettings == null)
{
if (log.IsErrorEnabled)
{
log.Error("pageSettings object passed to BlogIndexBuilderProvider.RebuildIndex was null");
}
return;
}
//don't index pending/unpublished pages
if (pageSettings.IsPending)
{
return;
}
log.Info("BlogIndexBuilderProvider indexing page - "
+ pageSettings.PageName);
//try
//{
Guid blogFeatureGuid = new Guid("D1D86E30-7864-40fe-BCBF-46E77AF80342");
ModuleDefinition blogFeature = new ModuleDefinition(blogFeatureGuid);
List <PageModule> pageModules
= PageModule.GetPageModulesByPage(pageSettings.PageId);
DataTable dataTable
= Blog.GetBlogsByPage(
pageSettings.SiteId,
pageSettings.PageId);
foreach (DataRow row in dataTable.Rows)
{
IndexItem indexItem = new IndexItem();
indexItem.SiteId = pageSettings.SiteId;
indexItem.PageId = pageSettings.PageId;
indexItem.PageName = pageSettings.PageName;
indexItem.ViewRoles = pageSettings.AuthorizedRoles;
indexItem.ModuleViewRoles = row["ViewRoles"].ToString();
indexItem.FeatureId = blogFeatureGuid.ToString();
indexItem.FeatureName = blogFeature.FeatureName;
indexItem.FeatureResourceFile = blogFeature.ResourceFile;
indexItem.ItemId = Convert.ToInt32(row["ItemID"], CultureInfo.InvariantCulture);
indexItem.ModuleId = Convert.ToInt32(row["ModuleID"], CultureInfo.InvariantCulture);
indexItem.ModuleTitle = row["ModuleTitle"].ToString();
indexItem.Title = row["Title"].ToString();
indexItem.ViewPage = row["ItemUrl"].ToString().Replace("~/", string.Empty);
indexItem.PageMetaDescription = row["MetaDescription"].ToString();
indexItem.PageMetaKeywords = row["MetaKeywords"].ToString();
DateTime blogStart = Convert.ToDateTime(row["StartDate"]);
if (indexItem.ViewPage.Length > 0)
{
indexItem.UseQueryStringParams = false;
}
else
{
indexItem.ViewPage = "Blog/ViewPost.aspx";
}
indexItem.Content = row["Description"].ToString();
int commentCount = Convert.ToInt32(row["CommentCount"]);
if (commentCount > 0)
{ // index comments
StringBuilder stringBuilder = new StringBuilder();
DataTable comments = Blog.GetBlogCommentsTable(indexItem.ModuleId, indexItem.ItemId);
foreach (DataRow commentRow in comments.Rows)
{
stringBuilder.Append(" " + commentRow["Comment"].ToString());
stringBuilder.Append(" " + commentRow["Name"].ToString());
if (log.IsDebugEnabled)
{
log.Debug("BlogIndexBuilderProvider.RebuildIndex add comment ");
}
}
indexItem.OtherContent = stringBuilder.ToString();
}
// lookup publish dates
foreach (PageModule pageModule in pageModules)
{
if (indexItem.ModuleId == pageModule.ModuleId)
{
indexItem.PublishBeginDate = pageModule.PublishBeginDate;
indexItem.PublishEndDate = pageModule.PublishEndDate;
}
}
if (blogStart > indexItem.PublishBeginDate)
{
indexItem.PublishBeginDate = blogStart;
}
IndexHelper.RebuildIndex(indexItem, indexPath);
if (log.IsDebugEnabled)
{
log.Debug("Indexed " + indexItem.Title);
}
}
//}
//catch (Exception ex)
//{
// log.Error(ex);
//}
}
/// <summary>
/// Parses nodes from the text
/// </summary>
/// <param name="itemstext">text containing the items</param>
/// <param name="parentItem">parent index item</param>
/// <param name="arrNodes">arraylist where the nodes should be added</param>
/// <param name="chmFile">CHMFile instance</param>
private static void ParseItems(string itemstext, IndexItem parentItem, ArrayList arrNodes, CHMFile chmFile)
{
int innerTextIdx = ObjectRE.GroupNumberFromName("innerText");
int innerPTextIdx = ParamRE.GroupNumberFromName("innerText");
// get group-name indexes
int nameIndex = AttributesRE.GroupNumberFromName("attributeName");
int valueIndex = AttributesRE.GroupNumberFromName("attributeValue");
int tdIndex = AttributesRE.GroupNumberFromName("attributeTD");
int nObjStartIndex = 0;
int nLastObjStartIndex = 0;
string sKeyword = "";
while (ObjectRE.IsMatch(itemstext, nObjStartIndex))
{
Match m = ObjectRE.Match(itemstext, nObjStartIndex);
string innerText = m.Groups[innerTextIdx].Value;
IndexItem idxItem = new IndexItem();
// read parameters
int nParamIndex = 0;
int nNameCnt = 0;
string paramTitle = "";
string paramLocal = "";
bool bAdded = false;
while (ParamRE.IsMatch(innerText, nParamIndex))
{
Match mP = ParamRE.Match(innerText, nParamIndex);
string innerP = mP.Groups[innerPTextIdx].Value;
string paramName = "";
string paramValue = "";
int nAttrIdx = 0;
//sKeyword = "";
while (AttributesRE.IsMatch(innerP, nAttrIdx))
{
Match mA = AttributesRE.Match(innerP, nAttrIdx);
string attributeName = mA.Groups[nameIndex].Value;
string attributeValue = mA.Groups[valueIndex].Value;
string attributeTD = mA.Groups[tdIndex].Value;
if (attributeTD.Length > 0)
{
// delete the trailing textqualifier
if (attributeValue.Length > 0)
{
int ltqi = attributeValue.LastIndexOf(attributeTD);
if (ltqi >= 0)
{
attributeValue = attributeValue.Substring(0, ltqi);
}
}
}
if (attributeName.ToLower() == "name")
{
paramName = HttpUtility.HtmlDecode(attributeValue); // for unicode encoded values
nNameCnt++;
}
if (attributeName.ToLower() == "value")
{
paramValue = HttpUtility.HtmlDecode(attributeValue); // for unicode encoded values
// delete trailing /
while ((paramValue.Length > 0) && (paramValue[paramValue.Length - 1] == '/'))
{
paramValue = paramValue.Substring(0, paramValue.Length - 1);
}
}
nAttrIdx = mA.Index + mA.Length;
}
if (nNameCnt == 1) // first "Name" param = keyword
{
sKeyword = "";
if (parentItem != null)
{
sKeyword = parentItem.KeyWordPath + ",";
}
string sOldKW = sKeyword;
sKeyword += paramValue;
IndexItem idxFind = FindByKeyword(arrNodes, sKeyword);
if (idxFind != null)
{
idxItem = idxFind;
}
else
{
if (sKeyword.Split(new char[] { ',' }).Length > 1)
{
idxItem.CharIndex = sKeyword.Length - paramValue.Length;
}
else
{
sKeyword = paramValue;
sOldKW = sKeyword;
idxItem.CharIndex = 0;
}
idxItem.KeyWordPath = sKeyword;
idxItem.Indent = sKeyword.Split(new char[] { ',' }).Length - 1;
idxItem.IsSeeAlso = false;
sKeyword = sOldKW;
}
}
else
{
if ((nNameCnt > 2) && (paramName.ToLower() == "name"))
{
bAdded = true;
IndexTopic idxTopic = new IndexTopic(paramTitle, paramLocal, chmFile.CompileFile, chmFile.ChmFilePath);
idxItem.Topics.Add(idxTopic);
paramTitle = "";
paramLocal = "";
}
switch (paramName.ToLower())
{
case "name":
//case "keyword":
{
paramTitle = paramValue;
}; break;
case "local":
{
paramLocal = paramValue.Replace("../", "").Replace("./", "");
}; break;
case "type": // information type assignment for item
{
idxItem.InfoTypeStrings.Add(paramValue);
}; break;
case "see also":
{
idxItem.AddSeeAlso(paramValue);
idxItem.IsSeeAlso = true;
bAdded = true;
}; break;
}
}
nParamIndex = mP.Index + mP.Length;
}
if (!bAdded)
{
bAdded = false;
IndexTopic idxTopic = new IndexTopic(paramTitle, paramLocal, chmFile.CompileFile, chmFile.ChmFilePath);
idxItem.Topics.Add(idxTopic);
paramTitle = "";
paramLocal = "";
}
idxItem.ChmFile = chmFile;
arrNodes.Add(idxItem);
nLastObjStartIndex = nObjStartIndex;
nObjStartIndex = m.Index + m.Length;
}
}
/// <summary>
/// Constructs a new PeptideEntry, and reuses ImmutableList values from the
/// passed in dictionaries to prevent redundant object creation.
/// </summary>
public static PeptideEntry NewInstance(IDictionary <int, ImmutableList <int> > singletonIndexCache,
IDictionary <ImmutableList <int>, ImmutableList <int> > indexCache, IndexItem indexItem)
{
var peptideEntry = new PeptideEntry(indexItem,
((PeptideLibraryKey)indexItem.LibraryKey).GetModifications());
if (peptideEntry.ModificationIndexes.Count == 0)
{
return(peptideEntry);
}
ImmutableList <int> newIndexes;
if (peptideEntry.ModificationIndexes.Count == 1)
{
if (singletonIndexCache.TryGetValue(peptideEntry.ModificationIndexes[0], out newIndexes))
{
peptideEntry.ModificationIndexes = newIndexes;
}
else
{
singletonIndexCache.Add(peptideEntry.ModificationIndexes[0], peptideEntry.ModificationIndexes);
}
}
else
{
if (indexCache.TryGetValue(peptideEntry.ModificationIndexes, out newIndexes))
{
peptideEntry.ModificationIndexes = newIndexes;
}
else
{
indexCache.Add(peptideEntry.ModificationIndexes, peptideEntry.ModificationIndexes);
}
}
return(peptideEntry);
}
public override int HandleMap(IndexItem indexItem, IEnumerable mapResults, Lazy <IndexWriteOperation> writer, TransactionOperationContext indexContext, IndexingStatsScope stats)
{
throw new NotImplementedException();
}
/// <summary>
/// Decodes a block of url-string data
/// </summary>
/// <param name="dataBlock">block of data</param>
/// <param name="nOffset">current file offset</param>
/// <param name="indexBlocks">number of index blocks</param>
/// <returns>true if succeeded</returns>
private bool DecodeBlock(byte[] dataBlock, ref int nOffset, int indexBlocks)
{
bool bRet = true;
int nblockOffset = nOffset;
MemoryStream memStream = new MemoryStream(dataBlock);
BinaryReader binReader = new BinaryReader(memStream);
int freeSpace = binReader.ReadInt16(); // length of freespace
int nrOfEntries = binReader.ReadInt16(); // number of entries
bool bListingEndReached = false;
//while( (memStream.Position < (memStream.Length-freeSpace)) && (bRet) )
//{
int nIndexOfPrevBlock = -1;
int nIndexOfNextBlock = -1;
int nIndexOfChildBlock = 0;
if (_readListingBlocks)
{
nIndexOfPrevBlock = binReader.ReadInt32(); // -1 if this is the header
nIndexOfNextBlock = binReader.ReadInt32(); // -1 if this is the last block
}
else
{
nIndexOfChildBlock = binReader.ReadInt32();
}
for (int nE = 0; nE < nrOfEntries; nE++)
{
if (_readListingBlocks)
{
bListingEndReached = (nIndexOfNextBlock == -1);
string keyWord = BinaryReaderHelp.ExtractUTF16String(ref binReader, 0, true, _associatedFile.TextEncoding);
bool isSeeAlsoKeyword = (binReader.ReadInt16() != 0);
int indent = binReader.ReadInt16(); // indent of entry
int nCharIndex = binReader.ReadInt32();
binReader.ReadInt32();
int numberOfPairs = binReader.ReadInt32();
int[] nTopics = new int[numberOfPairs];
string[] seeAlso = new string[numberOfPairs];
for (int i = 0; i < numberOfPairs; i++)
{
if (isSeeAlsoKeyword)
{
seeAlso[i] = HttpUtility.HtmlDecode(BinaryReaderHelp.ExtractUTF16String(ref binReader, 0, true, _associatedFile.TextEncoding));
}
else
{
nTopics[i] = binReader.ReadInt32();
}
}
binReader.ReadInt32(); // unknown
int nIndexOfThisEntry = binReader.ReadInt32();
IndexItem newItem = new IndexItem(_associatedFile, keyWord, isSeeAlsoKeyword, indent, nCharIndex, nIndexOfThisEntry, seeAlso, nTopics);
_indexList.Add(newItem);
}
else
{
string keyWord = BinaryReaderHelp.ExtractUTF16String(ref binReader, 0, true, _associatedFile.TextEncoding);
bool isSeeAlsoKeyword = (binReader.ReadInt16() != 0);
int indent = binReader.ReadInt16(); // indent of entry
int nCharIndex = binReader.ReadInt32();
binReader.ReadInt32();
int numberOfPairs = binReader.ReadInt32();
int[] nTopics = new int[numberOfPairs];
string[] seeAlso = new string[numberOfPairs];
for (int i = 0; i < numberOfPairs; i++)
{
if (isSeeAlsoKeyword)
{
seeAlso[i] = BinaryReaderHelp.ExtractUTF16String(ref binReader, 0, true, _associatedFile.TextEncoding);
}
else
{
nTopics[i] = binReader.ReadInt32();
}
}
int nIndexChild = binReader.ReadInt32();
int nIndexOfThisEntry = -1;
IndexItem newItem = new IndexItem(_associatedFile, keyWord, isSeeAlsoKeyword, indent, nCharIndex, nIndexOfThisEntry, seeAlso, nTopics);
_indexList.Add(newItem);
}
}
//}
binReader.ReadBytes(freeSpace);
if (bListingEndReached)
{
_readListingBlocks = false;
}
return(bRet);
}
/// <summary>
/// Crea el documento de las páginas
/// </summary>
private void CreatePage(string strBookTitle, string pathTemp, DocWriterFactory writerFactory, DocumentModel documentRoot, IndexItem page)
{
string fileName = GetFileName(pathTemp, page);
// Crea la página
if (File.Exists(fileName))
{
string content = ConvertPageToNhtml(HelperFiles.LoadTextFile(fileName));
DocumentModel document;
// Si hay algo que meter en el documento ...
if (!content.IsEmpty())
{
document = writerFactory.CreatePage(documentRoot,
$"{page.PageNumber:000}. {page.Name}",
strBookTitle + " - " + page.Name,
documentRoot.Description + " - " + page.Name,
documentRoot.KeyWords, content);
}
else
{
document = documentRoot;
}
// Crea los documentos de las páginas hija
if (page.Items != null && page.Items.Count > 0)
{
foreach (IndexItem item in page.Items)
{
CreatePage(strBookTitle, pathTemp, writerFactory, document, item);
}
}
}
}
private void ConvertLightmap(Stream cacheStream, Dictionary <ResourceLocation, Stream> resourceStreams,
IndexItem blamLightmapTag, int zoneSetIndex, BspFlags bspMask)
{
var blamCache = BlamCache;
var blamLightmap = BlamCache.Deserializer.Deserialize <ScenarioLightmap>(
new CacheSerializationContext(ref blamCache, blamLightmapTag));
if (blamCache.Version < CacheVersion.Halo3ODST)
{
var lightmapTag = CacheContext.AllocateTag <ScenarioLightmap>(blamLightmapTag.Name);
var lightmap = blamLightmap;
for (int i = 0, j = 0; i < blamLightmap.Lightmaps.Count; i++)
{
if (((BspFlags)(1u << i) & bspMask) == 0)
{
continue;
}
var blamLbsp = blamLightmap.Lightmaps[i];
var Lbsp = (ScenarioLightmapBspData)PortTag.ConvertData(cacheStream, resourceStreams,
blamLbsp, blamLbsp, blamLightmapTag.Name);
Lbsp.Airprobes = new List <ScenarioLightmap.Airprobe>();
Lbsp.Airprobes.AddRange(blamLightmap.Airprobes);
Lbsp.BspIndex = (short)j++;
var LbspTag = CacheContext.AllocateTag <ScenarioLightmapBspData>($"{blamLightmapTag.Name}_{i}_data");
CacheContext.Serialize(cacheStream, LbspTag, Lbsp);
lightmap.LightmapDataReferences.Add(new ScenarioLightmap.LightmapDataReference()
{
LightmapData = LbspTag
});
}
lightmap.Airprobes.Clear();
CacheContext.Serialize(cacheStream, lightmapTag, lightmap);
}
else
{
var lightmapTag = CacheContext.AllocateTag <ScenarioLightmap>(blamLightmapTag.Name);
var lightmap = blamLightmap;
var newDataReferences = new List <ScenarioLightmap.LightmapDataReference>();
for (int i = 0, j = 0; i < blamLightmap.LightmapDataReferences.Count; i++)
{
if (((BspFlags)(1u << i) & bspMask) == 0)
{
continue;
}
var blamLbspTag = blamCache.GetIndexItemFromID(blamLightmap.LightmapDataReferences[i].LightmapData.Index);
var blamLbsp = blamCache.Deserializer.Deserialize <ScenarioLightmapBspData>(
new CacheSerializationContext(ref blamCache, blamLbspTag));
var Lbsp = (ScenarioLightmapBspData)PortTag.ConvertData(cacheStream, resourceStreams, blamLbsp, blamLbsp, blamLbspTag.Name);
Lbsp.BspIndex = (short)j++;
var LbspTag = CacheContext.AllocateTag <ScenarioLightmapBspData>(blamLbspTag.Name);
CacheContext.Serialize(cacheStream, LbspTag, Lbsp);
newDataReferences.Add(new ScenarioLightmap.LightmapDataReference()
{
LightmapData = LbspTag
});
}
lightmap.LightmapDataReferences = newDataReferences;
CacheContext.Serialize(cacheStream, lightmapTag, lightmap);
}
}
/// <summary>
/// Obtiene el nombre de archivo de una página
/// </summary>
private string GetFileName(string pathTemp, IndexItem page)
{
return(Path.Combine(pathTemp, page.URL).Replace("/", "\\"));
}
public void AddOffset(string idRef, long offset)
{
var scanNum = _artificialScanNum++;
long num;
if (NativeIdConversion.TryGetScanNumberLong(idRef, out num))
{
scanNum = num;
}
var item = new IndexItem(idRef, offset, scanNum);
AddMapForOffset(item);
_offsets.Add(item);
}
private void DoEthernetPort()
{
string subDir = @"MultiCommSerialTerminal\EthernetData";
string oldPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
subDir);
this.log.Info("DoEthernetPort", () => string.Format("oldPath:{0}", oldPath));
// Old storage exits
if (Directory.Exists(oldPath))
{
this.log.Info("DoEthernetPort", () => string.Format("Path exist"));
IIndexedStorageManager <Ethernet.Common.Net.DataModels.EthernetParams, DefaultFileExtraInfo> ethSt =
new IndexedStorageManager <Ethernet.Common.Net.DataModels.EthernetParams, DefaultFileExtraInfo>(
new JsonReadWriteSerializerIndented <Ethernet.Common.Net.DataModels.EthernetParams>(),
new JsonReadWriteSerializerIndented <IIndexGroup <DefaultFileExtraInfo> >());
ethSt.StorageSubDir = subDir;
ethSt.IndexFileName = "EthernetDataIndex.txt";
this.log.Info("DoEthernetPort", () => string.Format("Number Items:", ethSt.IndexedItems.Count));
foreach (var ndx in ethSt.IndexedItems)
{
Ethernet.Common.Net.DataModels.EthernetParams data = ethSt.Retrieve(ndx);
if (data != null)
{
//this.log.Info("DoEthernetPort", () => string.Format(""));
this.log.Info("DoEthernetPort", () => string.Format("Data good:{0}", data.Display));
// the objects have either Display or Name. So we will get it from the old index first part
string display = data.Display;
if (display.Length == 0)
{
string[] parts = ndx.Display.Split(':');
if (parts != null && parts.Length > 0)
{
display = parts[0];
}
}
EthernetParams newData = new EthernetParams()
{
UId = data.UId,
Display = display,
EthernetAddress = data.EthernetAddress,
EthernetServiceName = data.EthernetServiceName,
};
IIndexItem <EthernetExtraInfo> idx =
new IndexItem <EthernetExtraInfo>(newData.UId, new EthernetExtraInfo(newData))
{
Display = newData.Display,
};
bool ok = this.ethernetStorage.Store(newData, idx);
this.log.Info("DoEthernetPort", () => string.Format("Stored result:{0}", ok));
}
}
// Try it once
ethSt.DeleteStorageDirectory();
}
}
public OperateResult Index(string index, IndexItem indexItem)
{
return(Index(index, indexItem.IndexType, indexItem.IndexKey, indexItem.FieldsToJson(), indexItem.ParentKey));
}
/// <summary>
/// Installs or updates Unturned 3 game files.
/// </summary>
/// <returns></returns>
public Task <U3InstallationState> Update()
{
return(Task.Run(() =>
{
this.Aborted = false;
bool busy = false;
try
{
busy = Convert.ToBoolean(new WebClient().DownloadString(baseUrl + "/busy.php"));
}
catch (Exception) { }
while (busy && !Aborted)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.PausedServerBusy));
Task.Delay(5000).Wait();
try
{
busy = Convert.ToBoolean(new WebClient().DownloadString(baseUrl + "/busy.php"));
}
catch (Exception) { }
}
if (Aborted)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.AbortedByCall));
return U3InstallationState.AbortedByCall;
}
string json = null;
try
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.SearchingUpdates));
long time = (FreshInstall || Validate) ? 0 : LastUpdate;
json = new WebClient().DownloadString(string.Format(indexUrl, time));
}
catch (Exception)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.FailedInternet));
return U3InstallationState.FailedInternet;
}
if (string.IsNullOrEmpty(json) || json.Equals("[]"))
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.Ok));
return U3InstallationState.Ok;
}
else
{
try
{
JObject index = JObject.Parse(json);
foreach (var item in index)
{
string file = item.Key;
string hash = (string)item.Value["hash"];
bool isFolder = (bool)item.Value["isFolder"];
long lastModified = (long)item.Value["lastModified"];
IndexItem i = new IndexItem(file, hash, isFolder, lastModified);
items.Add(i);
}
}
catch (Exception)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.FailedInvalidResponse, 0, 0));
return U3InstallationState.FailedInvalidResponse;
}
SemaphoreSlim taskBarrier = new SemaphoreSlim(DegreeOfParallelism);
int executed = 0;
int errors = 0;
int total = items.Count;
if (total > 0)
{
U3OnlineInstallerAskForUserToAcceptUpdate args = new U3OnlineInstallerAskForUserToAcceptUpdate();
AskForAcceptUpdate?.Invoke(this, args);
if (args.cancel)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.Ok, executed, total));
return U3InstallationState.Ok;
}
}
Task waitHandle = Task.Run(async() =>
{
while (taskBarrier.CurrentCount != DegreeOfParallelism || executed != total)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.Downloading, executed, total));
await Task.Delay(UpdateInterval);
}
});
if (FreshInstall)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.DeletingOldFiles));
DeleteOldFiles();
}
foreach (var item in items)
{
if (Aborted)
{
break;
}
string filename = installDir.FullName + "\\" + item.name.Substring(5);
if (item.isFolder)
{
try
{
if (!Directory.Exists(filename))
{
Directory.CreateDirectory(filename);
}
}
catch (Exception)
{
errors++;
}
}
else
{
taskBarrier.Wait();
Task.Run(() =>
{
string dl = this.baseUrl + item.name;
try
{
FileInfo info = new FileInfo(filename);
if (!info.Directory.Exists)
{
info.Directory.Create();
}
if (Validate && File.Exists(filename))
{
string originMD5 = item.hash;
string fileMD5 = UtilsGeneral.GetMD5HashOfFile(filename);
if (!fileMD5.Equals(originMD5))
{
WebClient client = new WebClient();
client.DownloadFile(dl, filename);
}
}
else
{
WebClient client = new WebClient();
client.DownloadFile(dl, filename);
}
}
catch (Exception)
{
errors++;
}
taskBarrier.Release();
});
}
executed++;
}
waitHandle.Wait();
if (Aborted)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.AbortedByCall, executed, total, errors));
return U3InstallationState.AbortedByCall;
}
LastUpdate = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
if (errors > 0)
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.FailedSome, executed, total, errors));
return U3InstallationState.FailedSome;
}
else
{
InstallationProgressChanged?.Invoke(this, new U3OnlineInstallationProgressArgs(U3InstallationState.Ok, executed, total));
return U3InstallationState.Ok;
}
}
}));
}
/// <summary> Rebuilds the index. </summary>
/// <param name="pageSettings"> The page settings. </param>
/// <param name="indexPath"> The index path. </param>
public override void RebuildIndex(PageSettings pageSettings, string indexPath)
{
if (WebConfigSettings.DisableSearchIndex)
{
return;
}
if (pageSettings == null)
{
return;
}
//don't index pending/unpublished pages
if (pageSettings.IsPending)
{
return;
}
Log.Info("ReservationEventIndexBuilderProvider indexing page - " + pageSettings.PageName);
try
{
var reservationFeature = new ModuleDefinition(reservationFeatureGuid);
var pageModules = PageModule.GetPageModulesByPage(pageSettings.PageId);
var dataTable = ReservationEvent.GetEventsByPage(pageSettings.SiteId, pageSettings.PageId);
foreach (DataRow row in dataTable.Rows)
{
var indexItem = new IndexItem
{
SiteId = pageSettings.SiteId,
PageId = pageSettings.PageId,
PageName = pageSettings.PageName,
PageIndex = pageSettings.PageIndex,
ViewRoles = pageSettings.AuthorizedRoles,
ModuleViewRoles = row["ViewRoles"].ToString(),
FeatureId = reservationFeatureGuid.ToString(),
FeatureName = reservationFeature.FeatureName,
FeatureResourceFile = reservationFeature.ResourceFile,
ItemId = Convert.ToInt32(row["ItemID"], CultureInfo.InvariantCulture),
ModuleId = Convert.ToInt32(row["ModuleID"], CultureInfo.InvariantCulture),
ModuleTitle = row["ModuleTitle"].ToString(),
Title = row["Title"].ToString(),
Content = row["Description"].ToString(),
ViewPage = "Reservations/Details.aspx",
CreatedUtc = Convert.ToDateTime(row["CreatedDate"]),
LastModUtc = Convert.ToDateTime(row["LastModUtc"])
};
// lookup publish dates
foreach (var pageModule in pageModules)
{
if (indexItem.ModuleId == pageModule.ModuleId)
{
indexItem.PublishBeginDate = pageModule.PublishBeginDate;
indexItem.PublishEndDate = pageModule.PublishEndDate;
}
}
IndexHelper.RebuildIndex(indexItem, indexPath);
if (Log.IsDebugEnabled)
{
Log.Debug("Indexed " + indexItem.Title);
}
}
}
catch (System.Data.Common.DbException ex)
{
Log.Error(ex);
}
}
public void Visit(OrNode node)
{
var estimate = 0L;
var mode = Query.EvaluationMode.Index;
var include = new List <IEnumerable <IndexItem> >();
var fullScan = false;
// generate include enumerators
for (var i = 0; i < node.Inner.Count; i++)
{
node.Inner[i].Accept(this);
// optimize for the corner case where the full log is read i.e. the query
// "{time:time} [" or "Foo":event="a" or "Bar":event="b"
if (EstimatedCount == _log.Count)
{
fullScan = true;
}
else if (EstimatedCount > 0)
{
include.Add(Index);
}
mode = new[] { Mode, mode }.Max();
estimate += EstimatedCount;
}
// define the iterator function
IEnumerable <IndexItem> Iterator()
{
var enumerators = include.Select(i => Buffered(i).GetEnumerator()).ToArray();
var hasNext = enumerators.Select(i => i.MoveNext()).ToArray();
var last = new IndexItem();
while (hasNext.Any(i => i))
{
var lowest = enumerators.Where((a, i) => hasNext[i]).Aggregate <IEnumerator <IndexItem>, IEnumerator <IndexItem> >(null, (a, i) => a != null ? (a.Current.CompareTo(i.Current) < 0 ? a : i) : i);
if (last.CompareTo(lowest.Current) != 0)
{
yield return(lowest.Current);
last = lowest.Current;
}
hasNext[Array.IndexOf(enumerators, lowest)] = lowest.MoveNext();
}
};
// and set the results
EstimatedCount = Math.Min(estimate, _log.Count);
Mode = mode;
if (fullScan)
{
Index = _log.Search();
}
else if (include.Count == 1)
{
Index = include[0];
}
else
{
Index = Iterator();
}
}
public override void RebuildIndex(
PageSettings pageSettings,
string indexPath)
{
if (WebConfigSettings.DisableSearchIndex)
{
return;
}
if ((pageSettings == null) || (indexPath == null))
{
if (log.IsErrorEnabled)
{
log.Error("pageSettings object or index path passed to GroupTopicIndexBuilderProvider.RebuildIndex was null");
}
return;
}
//don't index pending/unpublished pages
if (pageSettings.IsPending)
{
return;
}
log.Info("GroupTopicIndexBuilderProvider indexing page - "
+ pageSettings.PageName);
try
{
List <PageModule> pageModules
= PageModule.GetPageModulesByPage(pageSettings.PageId);
Guid groupFeatureGuid = new Guid("E75BAF8C-7079-4d10-A122-1AA3624E26F2");
ModuleDefinition groupFeature = new ModuleDefinition(groupFeatureGuid);
DataTable dataTable = GroupTopic.GetPostsByPage(
pageSettings.SiteId,
pageSettings.PageId);
foreach (DataRow row in dataTable.Rows)
{
IndexItem indexItem = new IndexItem();
indexItem.SiteId = pageSettings.SiteId;
indexItem.PageId = pageSettings.PageId;
indexItem.PageName = pageSettings.PageName;
indexItem.ViewRoles = pageSettings.AuthorizedRoles;
indexItem.ModuleViewRoles = row["ViewRoles"].ToString();
indexItem.FeatureId = groupFeatureGuid.ToString();
indexItem.FeatureName = groupFeature.FeatureName;
indexItem.FeatureResourceFile = groupFeature.ResourceFile;
indexItem.ItemId = Convert.ToInt32(row["ItemID"]);
indexItem.ModuleId = Convert.ToInt32(row["ModuleID"]);
indexItem.ModuleTitle = row["ModuleTitle"].ToString();
indexItem.Title = row["Subject"].ToString();
indexItem.Content = row["Post"].ToString();
indexItem.ViewPage = "Groups/Topic.aspx";
indexItem.QueryStringAddendum = "&topic="
+ row["TopicID"].ToString()
+ "&postid=" + row["PostID"].ToString();
// lookup publish dates
foreach (PageModule pageModule in pageModules)
{
if (indexItem.ModuleId == pageModule.ModuleId)
{
indexItem.PublishBeginDate = pageModule.PublishBeginDate;
indexItem.PublishEndDate = pageModule.PublishEndDate;
}
}
IndexHelper.RebuildIndex(indexItem, indexPath);
if (log.IsDebugEnabled)
{
log.Debug("Indexed " + indexItem.Title);
}
}
}
catch (System.Data.Common.DbException ex)
{
log.Error(ex);
}
}
private IndexItem GetIndexItem(PageSettings pageSettings, int moduleID, Item item)
{
Module module = new Module(moduleID);
ModuleConfiguration config = new ModuleConfiguration(module);
if (!config.IncludeInSearch)
{
return(null);
}
SuperFlexiDisplaySettings displaySettings = new SuperFlexiDisplaySettings();
ModuleDefinition flexiFeature = new ModuleDefinition(config.FeatureGuid);
IndexItem indexItem = new IndexItem();
indexItem.SiteId = pageSettings.SiteId;
indexItem.PageId = pageSettings.PageId;
indexItem.PageName = pageSettings.PageName;
indexItem.ViewRoles = pageSettings.AuthorizedRoles;
indexItem.FeatureId = flexiFeature.FeatureGuid.ToString();
indexItem.FeatureName = String.IsNullOrWhiteSpace(config.ModuleFriendlyName) ? module.ModuleTitle : config.ModuleFriendlyName;
indexItem.FeatureResourceFile = flexiFeature.ResourceFile;
indexItem.ItemId = item.ItemID;
indexItem.CreatedUtc = item.CreatedUtc;
indexItem.LastModUtc = item.LastModUtc;
if (pageSettings.UseUrl)
{
if (pageSettings.UrlHasBeenAdjustedForFolderSites)
{
indexItem.ViewPage = pageSettings.UnmodifiedUrl.Replace("~/", string.Empty);
}
else
{
indexItem.ViewPage = pageSettings.Url.Replace("~/", string.Empty);
}
indexItem.UseQueryStringParams = false;
}
SearchDef searchDef = SearchDef.GetByFieldDefinition(item.DefinitionGuid);
bool hasSearchDef = true;
if (searchDef == null)
{
searchDef = new SearchDef();
hasSearchDef = false;
}
System.Text.StringBuilder sbTitle = new System.Text.StringBuilder(searchDef.Title);
System.Text.StringBuilder sbKeywords = new System.Text.StringBuilder(searchDef.Keywords);
System.Text.StringBuilder sbDescription = new System.Text.StringBuilder(searchDef.Description);
System.Text.StringBuilder sbLink = new System.Text.StringBuilder(searchDef.Link);
System.Text.StringBuilder sbLinkQueryAddendum = new System.Text.StringBuilder(searchDef.LinkQueryAddendum);
SiteSettings siteSettings = new SiteSettings(pageSettings.SiteGuid);
SuperFlexiHelpers.ReplaceStaticTokens(sbTitle, config, false, displaySettings, moduleID, pageSettings, siteSettings, out sbTitle);
SuperFlexiHelpers.ReplaceStaticTokens(sbKeywords, config, false, displaySettings, moduleID, pageSettings, siteSettings, out sbKeywords);
SuperFlexiHelpers.ReplaceStaticTokens(sbDescription, config, false, displaySettings, moduleID, pageSettings, siteSettings, out sbDescription);
SuperFlexiHelpers.ReplaceStaticTokens(sbLink, config, false, displaySettings, moduleID, pageSettings, siteSettings, out sbLink);
SuperFlexiHelpers.ReplaceStaticTokens(sbLinkQueryAddendum, config, false, displaySettings, moduleID, pageSettings, siteSettings, out sbLinkQueryAddendum);
foreach (ItemFieldValue fieldValue in ItemFieldValue.GetItemValues(item.ItemGuid))
{
Field field = new Field(fieldValue.FieldGuid);
if (field == null || !field.Searchable)
{
continue;
}
if (hasSearchDef)
{
sbTitle.Replace(field.Token, fieldValue.FieldValue);
sbKeywords.Replace(field.Token, fieldValue.FieldValue);
sbDescription.Replace(field.Token, fieldValue.FieldValue);
sbLink.Replace(field.Token, fieldValue.FieldValue);
sbLinkQueryAddendum.Replace(field.Token, fieldValue.FieldValue);
}
else
{
sbKeywords.Append(fieldValue.FieldValue);
}
if (debugLog)
{
log.DebugFormat("RebuildIndex indexing item [{0} = {1}]", field.Name, fieldValue.FieldValue);
}
}
if (hasSearchDef)
{
sbTitle.Replace("$_ItemID_$", item.ItemID.ToString());
sbKeywords.Replace("$_ItemID_$", item.ItemID.ToString());
sbDescription.Replace("$_ItemID_$", item.ItemID.ToString());
sbLink.Replace("$_ItemID_$", item.ItemID.ToString());
sbLinkQueryAddendum.Replace("$_ItemID_$", item.ItemID.ToString());
indexItem.Content = sbDescription.ToString();
indexItem.Title = sbTitle.ToString();
if (sbLink.Length > 0)
{
indexItem.ViewPage = sbLink.ToString();
}
if (sbLinkQueryAddendum.Length > 0)
{
indexItem.QueryStringAddendum = sbLinkQueryAddendum.ToString();
indexItem.UseQueryStringParams = false;
}
}
else
{
indexItem.ModuleTitle = pageSettings.PageName;
indexItem.Title = String.IsNullOrWhiteSpace(config.ModuleFriendlyName) ? module.ModuleTitle : config.ModuleFriendlyName;
}
indexItem.PageMetaKeywords = sbKeywords.ToString();
indexItem.Categories = sbKeywords.ToString();
return(indexItem);
}
private static void IndexItem(Blog blog)
{
if (WebConfigSettings.DisableSearchIndex)
{
return;
}
if (blog == null)
{
if (log.IsErrorEnabled)
{
log.Error("blog object passed to BlogIndexBuilderProvider.IndexItem was null");
}
return;
}
Module module = new Module(blog.ModuleId);
Guid blogFeatureGuid = new Guid("D1D86E30-7864-40fe-BCBF-46E77AF80342");
ModuleDefinition blogFeature = new ModuleDefinition(blogFeatureGuid);
// get comments so they can be indexed too
StringBuilder stringBuilder = new StringBuilder();
using (IDataReader comments = Blog.GetBlogComments(blog.ModuleId, blog.ItemId))
{
while (comments.Read())
{
stringBuilder.Append(" " + comments["Comment"].ToString());
stringBuilder.Append(" " + comments["Name"].ToString());
if (log.IsDebugEnabled)
{
log.Debug("BlogIndexBuilderProvider.IndexItem add comment ");
}
}
}
// get list of pages where this module is published
List <PageModule> pageModules
= PageModule.GetPageModulesByModule(blog.ModuleId);
foreach (PageModule pageModule in pageModules)
{
PageSettings pageSettings
= new PageSettings(
blog.SiteId,
pageModule.PageId);
//don't index pending/unpublished pages
if (pageSettings.IsPending)
{
continue;
}
IndexItem indexItem = new IndexItem();
if (blog.SearchIndexPath.Length > 0)
{
indexItem.IndexPath = blog.SearchIndexPath;
}
indexItem.SiteId = blog.SiteId;
indexItem.PageId = pageSettings.PageId;
indexItem.PageName = pageSettings.PageName;
indexItem.ViewRoles = pageSettings.AuthorizedRoles;
indexItem.ModuleViewRoles = module.ViewRoles;
if (blog.ItemUrl.Length > 0)
{
indexItem.ViewPage = blog.ItemUrl.Replace("~/", string.Empty);
indexItem.UseQueryStringParams = false;
}
else
{
indexItem.ViewPage = "Blog/ViewPost.aspx";
}
indexItem.PageMetaDescription = blog.MetaDescription;
indexItem.PageMetaKeywords = blog.MetaKeywords;
indexItem.ItemId = blog.ItemId;
indexItem.ModuleId = blog.ModuleId;
indexItem.ModuleTitle = module.ModuleTitle;
indexItem.Title = blog.Title;
indexItem.Content = blog.Description + " " + blog.MetaDescription + " " + blog.MetaKeywords;
indexItem.FeatureId = blogFeatureGuid.ToString();
indexItem.FeatureName = blogFeature.FeatureName;
indexItem.FeatureResourceFile = blogFeature.ResourceFile;
indexItem.OtherContent = stringBuilder.ToString();
indexItem.PublishBeginDate = pageModule.PublishBeginDate;
indexItem.PublishEndDate = pageModule.PublishEndDate;
if (blog.StartDate > pageModule.PublishBeginDate)
{
indexItem.PublishBeginDate = blog.StartDate;
}
IndexHelper.RebuildIndex(indexItem);
}
if (log.IsDebugEnabled)
{
log.Debug("Indexed " + blog.Title);
}
}
public override void RebuildIndex(PageSettings pageSettings, string indexPath)
{
if (WebConfigSettings.DisableSearchIndex)
{
return;
}
if (pageSettings == null)
{
log.Error("RebuildIndex error: pageSettings was null ");
return;
}
//don't index pending/unpublished pages
if (pageSettings.IsPending)
{
return;
}
log.InfoFormat("RebuildIndex indexing page [{0}]", pageSettings.PageName);
try
{
DataTable dataTable = Item.GetByCMSPage(pageSettings.SiteGuid, pageSettings.PageId);
foreach (DataRow row in dataTable.Rows)
{
Item item = new Item(Convert.ToInt32(row["ItemID"]));
if (item == null)
{
continue;
}
log.InfoFormat("RebuildIndex indexing content [{0}]", row["ModuleTitle"]);
IndexItem indexItem = GetIndexItem(pageSettings, Convert.ToInt32(row["ModuleID"]), item);
if (indexItem == null)
{
continue;
}
indexItem.ModuleViewRoles = row["ModuleViewRoles"].ToString() + row["ItemViewRoles"].ToString();
indexItem.ModuleId = Convert.ToInt32(row["ModuleID"], CultureInfo.InvariantCulture);
indexItem.ModuleTitle = row["ModuleTitle"].ToString();
if (row["PublishBeginDate"] != DBNull.Value)
{
indexItem.PublishBeginDate = Convert.ToDateTime(row["PublishBeginDate"]);
}
if (row["PublishEndDate"] != DBNull.Value)
{
indexItem.PublishEndDate = Convert.ToDateTime(row["PublishEndDate"]);
}
IndexHelper.RebuildIndex(indexItem, indexPath);
if (debugLog)
{
log.DebugFormat("RebuildIndex [{0}\\{1}\\{2}]", indexItem.PageName, indexItem.ModuleTitle, indexItem.Title);
}
}
}
catch (System.Data.Common.DbException ex)
{
log.Error(ex);
}
}
public PeptideEntry(IndexItem indexItem, IList <KeyValuePair <int, string> > modifications)
{
IndexItem = indexItem;
ModificationIndexes = ImmutableList.ValueOf(modifications.Select(mod => mod.Key));
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="requestid"></param>
/// <param name="match"></param>
/// <param name="from"></param>
/// <param name="len"></param>
/// <param name="result"></param>
/// <created>UPh,20.03.2016</created>
/// <changed>UPh,20.03.2016</changed>
// ********************************************************************************
private void HandleProhibitedTerminologyMatch(bool bTargetLanguage, long requestid, IndexItem match, int from, int len, List<TerminologyResultArgs> result = null)
{
// Get TermInfo
TermBase termbase = _TermBases.FindTermBase(match.TermBaseID);
if (termbase == null)
return;
TermInfo terminfo = null;
if (!termbase.GetTermInfo(match.TermID, out terminfo, this))
return;
int langset = -1;
if (bTargetLanguage)
{
if (terminfo.LanguageSets.Count < 2)
return;
langset = 1;
}
else
{
if (terminfo.LanguageSets.Count < 1)
return;
langset = 0;
}
foreach (TermInfo.Term term in terminfo.LanguageSets[langset].Terms)
{
if (term.Props == null || term.Props.Status != TermStatus.prohibited)
continue;
ulong hash = TermIndex.MakeGlossaryHashCode(term.Text);
if (match.Hash != hash)
continue;
TerminologyResultArgs args = new TerminologyResultArgs();
args.Status = term.Props.Status;
args.RequestID = requestid;
args.TermBaseID = match.TermBaseID;
args.TermID = match.TermID;
args.FindFrom = from;
args.FindLen = len;
args.Term1 = term.Text;
args.Term2 = term.Text;
args.Origin = termbase.File.DisplayName;
args.Description = "";
if (result != null)
{
result.Add(args);
}
else
{
_TermbaseQuery.FireTerminologyResult(args);
}
}
}
public IndexTable(CacheFile cache)
{
var indexHeader = cache.IndexHeader;
var cacheHeader = cache.Header;
var reader = cache.Reader;
ClassList = new List <TagClass>();
#region Read Class List
reader.SeekTo(indexHeader.TagGroupsOffset);
for (int i = 0; i < indexHeader.TagGroupCount; i++)
{
var tc = new TagClass()
{
ClassCode = reader.ReadString(4),
Parent = reader.ReadString(4),
Parent2 = reader.ReadString(4),
StringID = reader.ReadInt32()
};
ClassList.Add(tc);
}
#endregion
#region Read Tags Info
reader.SeekTo(indexHeader.TagsOffset);
for (int i = 0; i < indexHeader.TagCount; i++)
{
IndexItem item = new IndexItem()
{
Cache = cache
};
item.ClassIndex = reader.ReadInt16();
item.ID = (reader.ReadInt16() << 16) | i;
item.Offset = reader.ReadInt32() - cache.Magic;
item.Index = i;
Add(item);
}
#endregion
#region Read Indices
reader.SeekTo(cacheHeader.TagNamesIndicesOffset);
int[] indices = new int[indexHeader.TagCount];
for (int i = 0; i < indexHeader.TagCount; i++)
{
indices[i] = reader.ReadInt32();
}
#endregion
#region Read Names
reader.SeekTo(cacheHeader.TagNamesBufferOffset);
EndianReader newReader = null;
if (cache.TagsKey == "" || cache.TagsKey == null)
{
newReader = new EndianReader(new MemoryStream(reader.ReadBytes(cacheHeader.TagNamesBufferSize)), EndianFormat.BigEndian);
}
else
{
reader.BaseStream.Position = cacheHeader.TagNamesBufferOffset;
newReader = new EndianReader(reader.DecryptAesSegment(cacheHeader.TagNamesBufferSize, cache.TagsKey), EndianFormat.BigEndian);
}
for (int i = 0; i < indices.Length; i++)
{
if (indices[i] == -1)
{
this[i].Name = "<null>";
continue;
}
newReader.SeekTo(indices[i]);
int length;
if (i == indices.Length - 1)
{
length = cacheHeader.TagNamesBufferSize - indices[i];
}
else
{
if (indices[i + 1] == -1)
{
int index = -1;
for (int j = i + 1; j < indices.Length; j++)
{
if (indices[j] != -1)
{
index = j;
break;
}
}
length = (index == -1) ? cacheHeader.TagNamesBufferSize - indices[i] : indices[index] - indices[i];
}
else
{
length = indices[i + 1] - indices[i];
}
}
if (length == 1)
{
this[i].Name = "<blank>";
continue;
}
if (length < 0)
{
int i0 = indices[i];
int i1 = indices[i + 1];
int i2 = indices[i + 2];
int i3 = indices[i + 3];
}
this[i].Name = newReader.ReadString(length);
}
newReader.Close();
newReader.Dispose();
#endregion
}
// ********************************************************************************
/// <summary>
///
/// </summary>
/// <param name="match"></param>
/// <returns></returns>
/// <created>UPh,14.11.2015</created>
/// <changed>UPh,14.11.2015</changed>
// ********************************************************************************
private void HandleTerminologyMatch(long requestid, IndexItem match, int from, int len, List<TerminologyResultArgs> result = null)
{
// Get TermInfo
TermBase termbase = _TermBases.FindTermBase(match.TermBaseID);
if (termbase == null)
return;
TermInfo terminfo = null;
if (!termbase.GetTermInfo(match.TermID, out terminfo, this))
return;
if (terminfo.LanguageSets.Count != 2)
return;
TermInfo.Term srcterm = null;
foreach (TermInfo.Term term in terminfo.LanguageSets[0].Terms)
{
ulong hash = TermIndex.MakeGlossaryHashCode(term.Text);
if (match.Hash != hash)
continue;
srcterm = term;
break;
}
if (srcterm == null)
return;
string definition = terminfo.Definition;
foreach (TermInfo.Term term in terminfo.LanguageSets[1].Terms)
{
TerminologyResultArgs args = new TerminologyResultArgs();
if (term.Props != null)
args.Status = term.Props.Status;
else
args.Status = TermStatus.none;
args.RequestID = requestid;
args.TermBaseID = match.TermBaseID;
args.TermID = match.TermID;
args.FindFrom = from;
args.FindLen = len;
args.Term1 = srcterm.Text;
args.Term2 = term.Text;
args.Origin = termbase.File.DisplayName;
args.Description = definition;
if (result != null)
{
result.Add(args);
}
else
{
_TermbaseQuery.FireTerminologyResult(args);
}
}
}
public IndexTable(Base.CacheFile Cache)
{
cache = Cache;
var IH = cache.IndexHeader;
var CH = cache.Header;
var Reader = cache.Reader;
ClassList = new List<TagClass>();
#region Read Class List
Reader.SeekTo(IH.tagClassIndexOffset);
for (int i = 0; i < IH.tagClassCount; i++)
{
TagClass tc = new TagClass();
tc.ClassCode = Reader.ReadString(4);
tc.Parent = Reader.ReadString(4);
tc.Parent2 = Reader.ReadString(4);
tc.StringID = Reader.ReadInt32();
ClassList.Add(tc);
}
#endregion
#region Read Tags' Info
Reader.SeekTo(IH.tagInfoOffset);
for (int i = 0; i < IH.tagCount; i++)
{
IndexItem item = new IndexItem() { Cache = cache };
item.ClassIndex = Reader.ReadInt16();
item.ID = (Reader.ReadInt16() << 16) | i;
item.Offset = Reader.ReadInt32() - cache.Magic;
item.metaIndex = i;
this.Add(item);
}
#endregion
#region Read Indices
Reader.SeekTo(CH.fileTableIndexOffset);
int[] indices = new int[IH.tagCount];
for (int i = 0; i < IH.tagCount; i++)
indices[i] = Reader.ReadInt32();
#endregion
#region Read Names
Reader.SeekTo(CH.fileTableOffset);
EndianReader newReader = (cache.tagsKey == "" || cache.tagsKey == null)
? new EndianReader(new MemoryStream(Reader.ReadBytes(CH.fileTableSize)), EndianFormat.Big)
: AES.DecryptSegment(Reader, CH.fileTableOffset, CH.fileTableSize, cache.tagsKey);
for (int i = 0; i < indices.Length; i++)
{
if (indices[i] == -1)
{
this[i].Filename = "<null>";
continue;
}
newReader.SeekTo(indices[i]);
int length;
if (i == indices.Length - 1)
length = CH.fileTableSize - indices[i];
else
{
if (indices[i + 1] == -1)
{
int index = -1;
for (int j = i + 1; j < indices.Length; j++)
{
if (indices[j] != -1)
{
index = j;
break;
}
}
length = (index == -1) ? CH.fileTableSize - indices[i] : indices[index] - indices[i];
}
else
length = indices[i + 1] - indices[i];
}
if (length == 1)
{
this[i].Filename = "<blank>";
continue;
}
if (length < 0)
{
int i0 = indices[i];
int i1 = indices[i + 1];
int i2 = indices[i + 2];
int i3 = indices[i + 3];
}
this[i].Filename = newReader.ReadString(length);
}
newReader.Close();
newReader.Dispose();
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public IndexOperation(IndexItem item, IndexOperationType operation)
{
Item = item;
Operation = operation;
}
