} //是否是结构体
public GenerateScorpioClass(Type type)
{
m_Type = type;
IsStruct = !type.IsClass;
FullName = ScorpioReflectUtil.GetFullName(m_Type);
ScorpioClassName = "ScorpioClass_" + ScorpioReflectUtil.GetGenerateClassName(type);
AllFields.AddRange(m_Type.GetFields(ScorpioReflectUtil.BindingFlag));
AllEvents.AddRange(m_Type.GetEvents(ScorpioReflectUtil.BindingFlag));
var propertys = m_Type.GetProperties(ScorpioReflectUtil.BindingFlag);
foreach (var property in propertys)
{
//如果是 get 则参数是0个 set 参数是1个 否则就可能是 [] 的重载
if ((property.CanRead && property.GetGetMethod().GetParameters().Length == 0) ||
(property.CanWrite && property.GetSetMethod().GetParameters().Length == 1))
{
AllPropertys.Add(property);
}
}
var methods = (m_Type.IsAbstract && m_Type.IsSealed) ? m_Type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy) : m_Type.GetMethods(ScorpioReflectUtil.BindingFlag);
foreach (var method in methods)
{
//屏蔽掉 模版函数 模板函数只能使用反射
if (!ScorpioReflectUtil.CheckGenericMethod(method))
{
continue;
}
AllMethods.Add(method);
}
}
private void GenerateCctor()
{
var allEvents = AllEvents
.Where(x => x.GetCustomAttribute <InvokeAttribute>() != null &&
x.GetCustomAttribute <InvokeAttribute>().DispatchingStrategy == Dispatch.SerializePerType)
.ToList();
if (allEvents.Count == 0)
{
return;
}
_perTypeScheduler = _typeBuilder.DefineField(
"PerTypeScheduler",
typeof(SerialTaskScheduler),
FieldAttributes.Private | FieldAttributes.InitOnly | FieldAttributes.Static);
var cctor = _typeBuilder.DefineTypeInitializer();
var gen = cctor.GetILGenerator();
gen.Emit(OpCodes.Ldstr, InterfaceType.FullName);
gen.Emit(OpCodes.Ldnull);
var loc = gen.DeclareLocal(typeof(ulong?));
gen.Emit(OpCodes.Ldloca, loc);
gen.Emit(OpCodes.Initobj, typeof(ulong?));
gen.Emit(OpCodes.Ldloc, loc);
gen.Emit(OpCodes.Ldc_I4_0);
gen.Emit(OpCodes.Newobj, Methods.SerialTaskSchedulerCtor);
gen.Emit(OpCodes.Stsfld, _perTypeScheduler);
gen.Emit(OpCodes.Ret);
}
/// <summary>
/// Tries to find a disassembled entity, given a disassembled target.
/// </summary>
/// <param name="disassemblyTarget">The disassembly target.</param>
/// <returns></returns>
public DisassembledEntity FindDisassembledEntity(DisassemblyTarget disassemblyTarget)
{
// If there's no target, we can't find anything.
if (disassemblyTarget == null)
{
return(null);
}
switch (disassemblyTarget.TargetType)
{
case DisassemblyTargetType.Class:
// Find the class with the given name.
return(AllClasses.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Enumeration:
// Find the enumeration with the given name.
return(AllEnumerations.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Method:
// Find the entity with the given name.
return(AllMethods.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Property:
// Find the entity with the given name.
return(AllProperties.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Field:
// Find the entity with the given name.
return(AllFields.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Structure:
// Find the structure with the given name.
return(AllStructures.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Interface:
// Find the structure with the given name.
return(AllInterfaces.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Event:
// Find the structure with the given name.
return(AllEvents.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
case DisassemblyTargetType.Delegate:
// Find the structure with the given name.
return(AllDelegates.FirstOrDefault(c => c.FullName == disassemblyTarget.FullName));
default:
throw new ArgumentOutOfRangeException();
}
}
protected bool Equals(ProjectionSourceDefinition other)
{
return(AllEvents.Equals(other.AllEvents) && AllStreams.Equals(other.AllStreams) &&
ByStream.Equals(other.ByStream) && ByCustomPartitions.Equals(other.ByCustomPartitions) &&
Equals(Categories, other.Categories) && Equals(Events, other.Events) &&
Equals(Streams, other.Streams) && string.Equals(CatalogStream, other.CatalogStream) &&
LimitingCommitPosition == other.LimitingCommitPosition && Equals(Options, other.Options));
}
public async Task DoLoadCalendarEventsGrouped(DateTime dStart, DateTime dEnd, int iMax = 0)
{
try
{
var newEvents = new SortedDictionary <DateTime, SortedDictionary <DateTime, CalendarEvent> >();
await DoLoadCalendarEventsListed(dStart, dEnd, iMax);
int iMs = 0;
foreach (CalendarEvent calEvent in ListedDates)
{
DateTime tFirstDay = calEvent.Start;
if (tFirstDay < dStart)
{
tFirstDay = dStart;
}
DateTime tLastDay = calEvent.End;
if (tFirstDay > dEnd)
{
tLastDay = dEnd;
}
for (DateTime tDay = tFirstDay.Date; tDay < tLastDay; tDay = tDay.AddDays(1))
{
iMs++;
if (!newEvents.ContainsKey(tDay))
{
newEvents.Add(tDay, new SortedDictionary <DateTime, CalendarEvent>());
}
newEvents[tDay].Add(calEvent.SortTime.AddMilliseconds(iMs), calEvent);
}
}
base.Clear();
int iCount = 0;
var allEvents = new List <CalendarEvent>();
var allDatesAndEvents = new List <object>();
foreach (DateTime d in newEvents.Keys)
{
base[d] = newEvents[d].Values;
iCount += newEvents[d].Count;
allDatesAndEvents.Add(d);
allDatesAndEvents.AddRange(newEvents[d].Values);
allEvents.AddRange(newEvents[d].Values);
}
AllEvents.Clear();
AllEvents.AddRange(allEvents);
AllDatesAndEvents.Clear();
AllDatesAndEvents.AddRange(allDatesAndEvents);
allEvents.Clear();
allDatesAndEvents.Clear();
}
catch (Exception ex)
{
base.Clear();
ex.ToString();
xLog.Debug("Error reading Calendar Events: " + ex.GetType().Name + ": " + ex.Message);
}
}
public ActionResult DeleteConfirmedFavorite(int id)
{
Event @event = db.Events.Find(id);
var currentUser = manager.FindById(User.Identity.GetUserId());
AllEvents all = new AllEvents();
all._favorites = db.Favorites.Where(t => t.User.Id == currentUser.Id).ToList();
db.Favorites.Remove(all.DeleteFavorite(@event));
db.SaveChanges();
return(RedirectToAction("Favorites"));
}
public ActionResult MyFavorites()
{
AllEvents all = new AllEvents();
var currentUser = manager.FindById(User.Identity.GetUserId());
all._events = db.Events.ToList();
all._favorites = db.Favorites.Where(t => t.User.Id == currentUser.Id).ToList();
var events = all.ReturnFavoriteEvents();
return(PartialView(events));
}
private async void SetupSampleData()
{
var items = await SampleData.GetEventFeed();
foreach (var item in items)
{
FeatureEvents.Add(item);
MyEvents.Add(item);
AllEvents.Add(item);
}
}
public override int GetHashCode()
{
unchecked {
int hashCode = AllEvents.GetHashCode();
hashCode = (hashCode * 397) ^ AllStreams.GetHashCode();
hashCode = (hashCode * 397) ^ ByStream.GetHashCode();
hashCode = (hashCode * 397) ^ ByCustomPartitions.GetHashCode();
hashCode = (hashCode * 397) ^ LimitingCommitPosition.GetHashCode();
hashCode = (hashCode * 397) ^ (Options != null ? Options.GetHashCode() : 0);
return(hashCode);
}
}
//
public List <AllEvents> GetAllEvents(int CollectionNo, int InstallatioNo, int Top)
{
List <AllEvents> LstAllEvents = new List <AllEvents>();
try
{
BatchDataAccess Batch = _ExchangeConst != string.Empty ? new BatchDataAccess(new SqlConnection(_ExchangeConst)) : new BatchDataAccess(_ExchangeConst);
List <DoorEventRecord> DoorEvents;
IEnumerable <FaultEventRecord> FaultEvents;
IEnumerable <PowerEventRecord> PowerEvents;
DoorEvents = Batch.GetDoorEventData(CollectionNo, InstallatioNo, Top).ToList();
FaultEvents = Batch.GetFaultEventData(CollectionNo, InstallatioNo, Top).ToList();
PowerEvents = Batch.GetPowerEventData(CollectionNo, InstallatioNo, Top).ToList();
AllEvents Events;
foreach (var item in DoorEvents)
{
Events = new AllEvents();
Events.Type = "Door";
Events.Date = item.Date.GetUniversalDateFormat();
Events.Time = item.Date.GetUniversalTimeFormat();
Events.Duration = HelperFunctions.GetDuration(item.Duration);
Events.Description = item.Error_Code_Description;//Door_Event_Type.Trim();// == "3" ? "Cash Door open by " : "Slot Door open by " ;
LstAllEvents.Add(Events);
}
foreach (var item in FaultEvents)
{
Events = new AllEvents();
Events.Type = "Fault";
Events.Date = item.Date.GetUniversalDateFormat();
Events.Time = item.Date.GetUniversalTimeFormat();
Events.Duration = "n/a";
Events.Description = item.Fault_Description;
LstAllEvents.Add(Events);
}
foreach (var item in PowerEvents)
{
Events = new AllEvents();
Events.Type = "Power On";
Events.Date = item.Date.GetUniversalDateFormat();
Events.Time = item.Date.GetUniversalTimeFormat();
Events.Duration = HelperFunctions.GetDuration(item.Duration);
Events.Description = "";
LstAllEvents.Add(Events);
}
}
catch (Exception ex) { LogError(ex); }
return(LstAllEvents);
}
public PopupWindowAllEventsViewModel()
{
_realTableNameDict = new Dictionary <string, string>()
{
{ "事件记录表", "awms_events_dhl" },
{ "设备表", "awms_device_dhl" },
{ "灯信息表", "awms_lights_dhl" },
{ "灯任务表", "awms_lights_tasks_dhl" },
{ "LPN表", "awms_lpn_dhl" },
{ "订单表", "awms_orders_dhl" },
{ "发货单表", "awms_orders_tasks_dhl" },
{ "栈板表", "awms_pallets_dhl" },
{ "原始数据表", "awms_source_dhl" },
{ "库位表", "awms_storges_dhl" }
};
TableNames = new ObservableCollection <string>();
foreach (var x in _realTableNameDict.Keys)
{
TableNames.Add(x);
}
SelectedTableName = TableNames[0];
PageSize = 50;
ViewRefresh();
PageSizeChanged = new DelegateCommand(() =>
{
if (PageSize <= 0)
{
MessageBox.Show("页数必须是大于0的整数", "错误");
return;
}
CurrentPage = 1;
string tableName = _realTableNameDict[SelectedTableName];
TotalCount = DbHelper.GetTabelRecordCount(tableName);
//AllEvents = DbHelper.GetDataByPage(tableName, CurrentPage, PageSize);
if (null != AllEvents)
{
AllEvents.Dispose();
AllEvents = null;
}
AllEvents = DbHelper.GetAllFromTableByName(tableName);
TotalPages = (TotalCount + PageSize - 1) / PageSize;
});
ViewRefreshCommand = new DelegateCommand(ViewRefresh);
}
void ViewRefresh()
{
if (PageSize <= 0)
{
return;
}
string tableName = _realTableNameDict[SelectedTableName];
TotalCount = DbHelper.GetTabelRecordCount(tableName);
// AllEvents = DbHelper.GetDataByPage(tableName,CurrentPage, PageSize);
if (null != AllEvents)
{
AllEvents.Dispose();
AllEvents = null;
}
AllEvents = DbHelper.GetAllFromTableByName(tableName);
TotalPages = (TotalCount + PageSize - 1) / PageSize;
}
public ActionResult EventPage(int?id)
{
if (id == null)
{
// возвращает экземпляр класса HttpNotFound
return(HttpNotFound());
}
var currentUser = manager.FindById(User.Identity.GetUserId());
AllEvents all = new AllEvents();
all._events = db.Events.ToList();
all._favorites = db.Favorites.Where(t => t.User.Id == currentUser.Id).ToList();
var events = all.ReturnFavoriteEvents();
bool check = false;
int compare = 0;
Event @event = db.Events.FirstOrDefault(t => t.Id == id);
if (events.Count != 0)
{
if (events.Contains(@event))
{
check = true;
}
else
{
check = false;
}
}
if (currentUser.Equals(@event.User))
{
compare = 1;
}
ViewBag.Compare = compare;
ViewBag.CompareMessage = "Вы не можете добавить это событие в избранное так как вы являетесь его создателем";
ViewBag.Check = check;
ViewBag.MessageCheck = "Это событие уже находиться в ваших избранных";
return(View(@event));
}
public async Task GetAllEvents()
{
var feedResultEntity =
await
_eventManager.GetEvents(Locator.ViewModels.MainPageVm.CurrentTokens, "eventStartDate",
Locator.ViewModels.MainPageVm.CurrentUser.Region);
var result = await ResultChecker.CheckSuccess(feedResultEntity);
if (!result)
{
return;
}
var feedEntity = JsonConvert.DeserializeObject <EventsResponse>(feedResultEntity.ResultJson);
foreach (var feed in feedEntity.Events)
{
AllEvents.Add(feed);
}
}
private void SendEventFromStatus(string statusFilePath)
{
lock (@lock)
{
var @event = FromJsonFile <StatusEvent>(statusFilePath);
if (@event != null)
{
if ([email protected](_currentGameStatus))
{
_currentGameStatus = @event;
GameEvents.InvokeEvent(@event);
AllEvents?.Invoke(this, new ProcessedEvent
{
EventName = @event.Event.ToLower(),
EventType = typeof(StatusEvent),
Event = @event
});
}
}
}
}
internal JournalEvent ExecuteEvent(string eventName, string json)
{
var rawEvent = new OriginalEvent {
EventName = eventName, Source = json
};
BeforeEvent?.Invoke(this, rawEvent);
if (rawEvent.Ignore)
{
return(null);
}
if (_cache.Value.TryGetValue(eventName, out var eventCacheItem))
{
JournalEvent @event = null;
try
{
@event = (JournalEvent)eventCacheItem.Execute.Invoke(null, new object[] { json, this });
}
catch (Exception exception)
{
LogJournalException(new JournalRecordException(json, exception));
}
if (@event != null)
{
AllEvents?.Invoke(this, new ProcessedEvent
{
EventName = eventCacheItem.Name,
EventType = eventCacheItem.Type,
Event = @event
});
}
return(@event);
}
LogJournalWarning(new JournalEventNotFoundException(eventName, json));
return(null);
}
async Task ExecuteRefreshCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
var table = await CloudService.GetTableAsync <Event>();
var list = await table.ReadAllEventsAsync();
AllEvents.Clear();
DatesWithEvents.Clear();
foreach (var currentEvent in list)
{
AllEvents.Add(currentEvent);
SpecialDate specialDate = new SpecialDate(currentEvent.Date);
specialDate.Selectable = true;
specialDate.BorderColor = Color.White;
specialDate.BorderWidth = 2;
DatesWithEvents.Add(specialDate);
}
ShowEventsOfTheDay();
await CloudService.SyncOfflineCacheAsync();
}
catch (Exception ex)
{
Debug.WriteLine($"[EventsViewModel] Error loading events: {ex.Message}");
}
finally
{
IsBusy = false;
}
}
///
/// <summary>
/// This calculates row for each of event (makes sense only for main band).
/// We try to place evens so that the do not overlap on the screen.</summary>
///
public void CalculateEventRows(
)
{
int count;
int rowCount;
int minIndex;
DateTime[] dates;
DateTime minDate;
TimelineEvent e;
int overrideRowCount;
Debug.Assert(m_assignRows);
Debug.Assert(AllEvents != null);
Utilities.Trace(this);
rowCount = (int)((PixelHeight - TOP_MARGIN - BOTTOM_MARGIN) / m_maxEventHeight);
if (AllEvents.Count > 0)
{
overrideRowCount = AllEvents.Max((s) => { return(s.RowOverride); }) + 1;
rowCount = Math.Max(rowCount, overrideRowCount);
}
if (rowCount == 0)
{
for (int i = 0; i < AllEvents.Count; ++i)
{
e = AllEvents[i];
e.Row = 0;
}
}
else
{
dates = new DateTime[rowCount];
for (int i = 0; i < rowCount; ++i)
{
dates[i] = new DateTime();
}
count = AllEvents.Count;
for (int i = 0; i < count; ++i)
{
minDate = dates[0];
minIndex = 0;
e = AllEvents[i];
if (e.RowOverride == -1)
{
for (int k = 0; k < rowCount; ++k)
{
if (minDate > dates[k])
{
minIndex = k;
minDate = dates[k];
}
}
dates[minIndex] = e.EndDate;
e.Row = minIndex;
}
else
{
e.Row = e.RowOverride;
dates[e.Row] = e.EndDate;
}
}
}
}
public void TriggerEvent(string name)
{
AllEvents.First(x => x.guiName == name).Invoke();
}
public bool HasEvent(string name)
{
return(AllEvents.Any(x => x.guiName == name));
}
private void Form1_Load(object sender, EventArgs e)
{
Random random = new Random();
//Checks if the event database has already been created
//This will take a short while to create all the different events and fill the database
if (!File.Exists("Events.sqlite"))
{
//If its not created then create the database and add the table
SQLiteConnection.CreateFile("Events.sqlite");
dbConnect = new SQLiteConnection("Data Source=Events.sqlite;Version=3;");
dbConnect.Open();
SQLiteCommand commandLoggedIn = new SQLiteCommand("create table Events (user int, action varchar(10), latitude float, longitude float, date datetime)", dbConnect);
commandLoggedIn.ExecuteNonQuery();
//Runs loop 10,000 times to fill list with random events, locations and different users
for (int i = 0; i < 10000; i++)
{
AllEvents allEvents = new AllEvents();
allEvents.username = random.Next(100).ToString();
int actionNum = random.Next(5);
allEvents.action = GetAction();
allEvents.latitude = GetRandomNumber(-90, 90);
allEvents.longitude = GetRandomNumber(-180, 180);
allEvents.date = GetRandomDate();
//Inserts data into SQL database
string eventString = "";
eventString += "insert into Events (user, action, latitude, longitude, date) values(@username, @act, @lat, @long, @date)";
SQLiteCommand eventInsert = new SQLiteCommand(eventString, dbConnect);
eventInsert.Parameters.AddWithValue("@username", allEvents.username);
eventInsert.Parameters.AddWithValue("@act", allEvents.action.ToString());
eventInsert.Parameters.AddWithValue("@lat", allEvents.latitude);
eventInsert.Parameters.AddWithValue("@long", allEvents.longitude);
eventInsert.Parameters.AddWithValue("@date", allEvents.date);
eventInsert.ExecuteNonQuery();
}
}
else
{
//If database has been created then load it
dbConnect = new SQLiteConnection("Data Source=Events.sqlite;Version=3;");
dbConnect.Open();
}
//Add each event type to drop box
foreach (Event events in Enum.GetValues(typeof(Event)))
{
ActionSelection.Items.Add(events.ToString());
}
ActionSelection.Text = "All";
}
private void GenerateCtor()
{
var builder = _typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new[]
{
typeof(ulong),
typeof(IRemotingEndPoint),
typeof(IEndPointChannel),
typeof(ISerializer)
});
var gen = builder.GetILGenerator();
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Call, Methods.ObjectCtor);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Stfld, ObjectId);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg_2);
gen.Emit(OpCodes.Stfld, EndPoint);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg_3);
gen.Emit(OpCodes.Stfld, Channel);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldarg, 4);
gen.Emit(OpCodes.Stfld, Serializer);
var perObjectEvents = AllEvents
.Where(x => x.GetCustomAttribute <InvokeAttribute>() != null &&
x.GetCustomAttribute <InvokeAttribute>().DispatchingStrategy == Dispatch.SerializePerObject)
.ToList();
if (perObjectEvents.Count > 0)
{
_perObjectScheduler = _typeBuilder.DefineField("_perObjectScheduler",
typeof(SerialTaskScheduler),
FieldAttributes.Private | FieldAttributes.InitOnly);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldstr, InterfaceType.FullName);
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Newobj, Methods.NullableUInt64Ctor);
gen.Emit(OpCodes.Ldc_I4_0);
gen.Emit(OpCodes.Newobj, Methods.SerialTaskSchedulerCtor);
gen.Emit(OpCodes.Stfld, _perObjectScheduler);
}
var perMethodEvents = AllEvents
.Where(x => x.GetCustomAttribute <InvokeAttribute>() != null &&
x.GetCustomAttribute <InvokeAttribute>().DispatchingStrategy == Dispatch.SerializePerMethod)
.ToList();
foreach (var eventInfo in perMethodEvents)
{
var scheduler = _typeBuilder.DefineField(string.Format("_{0}", eventInfo.Name),
typeof(SerialTaskScheduler),
FieldAttributes.Private | FieldAttributes.InitOnly);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldstr, InterfaceType.FullName);
gen.Emit(OpCodes.Ldstr, eventInfo.Name);
gen.Emit(OpCodes.Ldarg_1);
gen.Emit(OpCodes.Newobj, Methods.NullableUInt64Ctor);
gen.Emit(OpCodes.Ldc_I4_0);
gen.Emit(OpCodes.Newobj, Methods.SerialTaskSchedulerCtor);
gen.Emit(OpCodes.Stfld, scheduler);
_perEventSchedulers.Add(eventInfo, scheduler);
}
gen.Emit(OpCodes.Ret);
}
private async Task SetEvents(ObservableCollection <Event> model)
{
try
{
if (model != null)
{
var usermodel = await LocalStorage.ReadJsonFromFile <UserRegistrationPageViewModel>("registration");
if (usermodel != null)
{
var list = new ObservableCollection <Event>();
foreach (var ev in model)
{
try
{
if (usermodel.SelectedAudienceType.AudienceTypeName == "Student" &&
(ev.EventType == "Firstparty_ProDev") && ev.EventRoles.Contains(usermodel.SelectedAudienceType.AudienceTypeName) == false)
{
continue;
}
ev.Weightage = 1;
if (ev.GlobalEvent)
{
ev.Weightage = 10;
continue;
}
if (ev.EventType == "Webinar" &&
ev.EventRoles.Contains(usermodel.SelectedAudienceType.AudienceTypeName))
{
bool found = false;
foreach (var tech in ev.EventTechnologies)
{
if (
usermodel.SecondaryTechnologies.FirstOrDefault(
x => x.IsSelected && x.PrimaryTechnologyName == tech) != null)
{
found = true;
break;
}
}
if (found)
{
ev.Weightage = 5;
}
else
{
ev.Weightage = 4;
}
continue;
}
if (ev.EventRoles.Contains(usermodel.SelectedAudienceType.AudienceTypeName) &&
ev.CityName == usermodel.City.CityName)
{
bool found = false;
foreach (var tech in ev.EventTechnologies)
{
if (
usermodel.SecondaryTechnologies.FirstOrDefault(
x => x.IsSelected && x.PrimaryTechnologyName == tech) != null)
{
found = true;
break;
}
}
if (found)
{
ev.Weightage = 9;
}
else
{
ev.Weightage = 8;
}
continue;
}
if (ev.EventRoles.Contains(usermodel.SelectedAudienceType.AudienceTypeName))
{
bool found = false;
foreach (var tech in ev.EventTechnologies)
{
if (
usermodel.SecondaryTechnologies.FirstOrDefault(
x => x.IsSelected && x.PrimaryTechnologyName == tech) != null)
{
found = true;
break;
}
}
if (found)
{
ev.Weightage = 7;
}
else
{
ev.Weightage = 6;
}
continue;
}
}
catch (Exception)
{
}
}
model = new ObservableCollection <Event>(model.OrderByDescending(x => x.Weightage));
this.AllEvents = model;
ObservableCollection <Event> recommendedmodel = null;
if (AllEvents.Count > 5)
{
recommendedmodel = new ObservableCollection <Event>(AllEvents.Take(5));
recommendedmodel.Add(new LoadMore());
}
else
{
recommendedmodel = AllEvents;
}
this.RecommendedEvents = recommendedmodel;
}
}
}
catch (Exception)
{
}
}
void Init()
{
(m_Fields = new List <FieldInfo>(AllFields.Where(_ => Check(_)))).SortField();
(m_Events = new List <EventInfo>(AllEvents.Where(_ => Check(_)))).SortEvent();
(m_Propertys = new List <PropertyInfo>(AllPropertys.Where(_ => Check(_)))).SortProperty();
m_Methods.Clear();
foreach (var method in AllMethods)
{
if (!Check(method))
{
continue;
}
var valid = true;
var methodHandle = method.MethodHandle;
//判断函数是不是 event add remove 函数
foreach (var eventInfo in AllEvents)
{
if (eventInfo.GetAddMethod().MethodHandle == methodHandle || eventInfo.GetRemoveMethod().MethodHandle == methodHandle)
{
if (!Check(eventInfo))
{
valid = false;
}
break;
}
}
if (valid)
{
//判断函数是不是 get set 函数
foreach (var propertyInfo in AllPropertys)
{
//如果是struct 并且是 set 属性则屏蔽,强转结构体的set会报错
if (IsStruct && propertyInfo.GetSetMethod()?.MethodHandle == methodHandle)
{
valid = false;
break;
}
else if (propertyInfo.GetGetMethod()?.MethodHandle == methodHandle || propertyInfo.GetSetMethod()?.MethodHandle == methodHandle)
{
if (!Check(propertyInfo))
{
valid = false;
}
break;
}
}
}
if (valid)
{
m_Methods.Add(method);
}
}
m_Methods.SortMethod();
m_ExtensionMethods.Clear();
foreach (var extensionInfo in m_Extensions)
{
var nameSpace = extensionInfo.Namespace;
var methods = extensionInfo.GetMethods(Script.BindingFlag);
foreach (var methodInfo in methods)
{
//非扩展函数
if (!Util.IsExtensionMethod(methodInfo) || !Check(methodInfo))
{
continue;
}
var paramterType = methodInfo.GetParameters()[0].ParameterType;
//判断是模板函数
if (paramterType.IsGenericParameter && paramterType.BaseType != null && paramterType.BaseType.IsAssignableFrom(m_Type))
{
m_ExtensionMethods.Add(methodInfo);
}
else if (ScorpioReflectUtil.CheckGenericMethod(methodInfo) && paramterType.IsAssignableFrom(m_Type))
{
m_ExtensionMethods.Add(methodInfo);
}
else
{
continue;
}
if (!string.IsNullOrWhiteSpace(nameSpace))
{
m_ExtensionUsing.Add(nameSpace);
}
}
}
m_ExtensionMethods.SortMethod();
m_Methods.ForEach(_ => m_MethodNames.Add(_.Name));
m_ExtensionMethods.ForEach(_ => m_MethodNames.Add(_.Name));
}
public Task <IEnumerable <IEntityEvent <Guid> > > GetEvents(DateTime start, DateTime end)
{
var events = AllEvents.Where(e => e.Timestamp >= start && e.Timestamp <= end);
return(Task.FromResult(events));
}
