private static void NimSignalingChannelsSyncCallback(IntPtr info_list, int size, IntPtr user_data)
{
List <NIMSignalingChannelDetailedinfo> channels = new List <NIMSignalingChannelDetailedinfo>();
if (info_list != IntPtr.Zero)
{
for (int i = 0; i < size; i++)
{
NIMSignalingChannelDetailedinfo channel_detailed_info = new NIMSignalingChannelDetailedinfo();
IntPtr detailed_ptr = NimUtility.IntPtrExtensions.Increment(info_list, i * Marshal.SizeOf(typeof(NIMSignalingChannelDetailedinfo_C)));
NIMSignalingChannelDetailedinfo_C detailed_info = (NIMSignalingChannelDetailedinfo_C)Marshal.PtrToStructure(detailed_ptr, typeof(NIMSignalingChannelDetailedinfo_C));
for (int j = 0; j < detailed_info.member_size_; j++)
{
IntPtr src_data = NimUtility.IntPtrExtensions.Increment(detailed_info.members_, j * Marshal.SizeOf(typeof(NIMSignalingMemberInfo_C)));
NIMSignalingMemberInfo_C member_info_c = (NIMSignalingMemberInfo_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingMemberInfo_C));
NIMSignalingMemberInfo member_info = SignalHelper.NIMSignalingMemberFromC(member_info_c);
channel_detailed_info.members_.Add(member_info);
}
channel_detailed_info.channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(detailed_info.channel_info_);
channels.Add(channel_detailed_info);
}
}
NimUtility.DelegateConverter.Invoke <NimSignalingChannelsSyncHandler>(user_data, channels);
}
protected override DiscreteSignal Render(NoteSegment segment)
{
DiscreteSignal mainSignal = null;
if (segment is PercussionNoteSegment percussionNoteSegment)
{
mainSignal = GetPercussionSignal(percussionNoteSegment.PercussionType, percussionNoteSegment.DurationSamples);
}
else if (segment is MelodicNoteSegment melodicNoteSegment)
{
// Combine a Sine wave and a Square wave
mainSignal = SignalHelper.GetSine(melodicNoteSegment.Frequency, melodicNoteSegment.DurationSamples);
mainSignal.CombineAdd(SignalHelper.GetSquare(melodicNoteSegment.Frequency, melodicNoteSegment.DurationSamples));
}
float velocityMultiplier = segment.Velocity / 127f; // Velocity ranges from 0 - 127
// A simple way of doing an equalizer
float balanceMultiplier = BalanceProvider.GetMultiplier(segment);
// Scale the signals based on their velocity and balance multipliers
mainSignal.Amplify(velocityMultiplier * balanceMultiplier);
mainSignal.ApplyAdsr(AdsrEnvelopeProvider.CreateEnvelope(segment));
return(mainSignal);
}
private static void NimSignalingOptAcceptCallback(int code, IntPtr opt_res_param, IntPtr user_data)
{
NIMSignalingAcceptResParam accept_res_param = new NIMSignalingAcceptResParam();
accept_res_param.info_ = new NIMSignalingChannelDetailedinfo();
NIMSignalingJoinResParam_C res_param_c = (NIMSignalingJoinResParam_C)Marshal.PtrToStructure(opt_res_param, typeof(NIMSignalingJoinResParam_C));
if (res_param_c != null)
{
accept_res_param.info_.channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(res_param_c.info_.channel_info_);
for (int i = 0; i < res_param_c.info_.member_size_; i++)
{
IntPtr src_data = NimUtility.IntPtrExtensions.Increment(res_param_c.info_.members_, i * Marshal.SizeOf(typeof(NIMSignalingMemberInfo_C)));
NIMSignalingMemberInfo_C member_info_c = (NIMSignalingMemberInfo_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingMemberInfo_C));
NIMSignalingMemberInfo member_info = SignalHelper.NIMSignalingMemberFromC(member_info_c);
accept_res_param.info_.members_.Add(member_info);
}
}
NIMSignalingRejectOrAcceptResCode res_code = NIMSignalingRejectOrAcceptResCode.kUnknown;
try
{
res_code = (NIMSignalingRejectOrAcceptResCode)Enum.Parse(typeof(NIMSignalingRejectOrAcceptResCode), code.ToString());
}
catch
{
res_code = NIMSignalingRejectOrAcceptResCode.kUnknown;
}
NimUtility.DelegateConverter.Invoke <NimSignalingOptAcceptHandler>(user_data, res_code, accept_res_param);
}
private static void NimSignalingOptCreateCallback(int code, IntPtr opt_res_param, IntPtr user_data)
{
NIMSignalingCreateResParam res_param = new NIMSignalingCreateResParam();
if (opt_res_param != IntPtr.Zero)
{
NIMSignalingCreateResParam_C res_param_c = (NIMSignalingCreateResParam_C)Marshal.PtrToStructure(opt_res_param, typeof(NIMSignalingCreateResParam_C));
res_param.channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(res_param_c.channel_info_);
}
NimUtility.DelegateConverter.Invoke <NimSignalingOptCreateHandler>(user_data, code, res_param);
}
/// <inheritdoc />
public DiscreteSignal CreateEnvelope(NoteSegment segment)
{
var adsrParameters = MelodicAdsrParameters;
if (segment is PercussionNoteSegment percussionNoteSegment)
{
adsrParameters = GetPercussionAdsrParameters(percussionNoteSegment.PercussionType);
}
return(SignalHelper.GetAdsrEnvelope(adsrParameters, segment.DurationSamples));
}
void SetNotificationBaseInfo(IntPtr ptr)
{
var notification = NimUtility.Utilities.IntPtrToStructure <CNotification>(ptr);
var notifyData = NimUtility.Utilities.IntPtrToStructure <CNotificationData>(notification.Data);
custom_info_ = NimUtility.Utilities.MarshalUtf8String(notifyData.custom_info_);
from_account_id_ = NimUtility.Utilities.MarshalUtf8String(notifyData.from_account_id_);
msg_id_ = notifyData.msg_id_;
var cChannel = NimUtility.Utilities.IntPtrToStructure <NIMSignalingChannelInfo_C>(notifyData.channel_info_);
channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(cChannel);
}
private static void NimSignalingOptJoinCallback(int code, IntPtr opt_res_param, IntPtr user_data)
{
NIMSignalingJoinResParam res_param = new NIMSignalingJoinResParam();
NIMSignalingJoinResParam_C res_param_c = (NIMSignalingJoinResParam_C)Marshal.PtrToStructure(opt_res_param, typeof(NIMSignalingJoinResParam_C));
res_param.info_.channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(res_param_c.info_.channel_info_);
for (int i = 0; i < res_param_c.info_.member_size_; i++)
{
IntPtr src_data = NimUtility.IntPtrExtensions.Increment(res_param_c.info_.members_, i * Marshal.SizeOf(typeof(NIMSignalingMemberInfo_C)));
NIMSignalingMemberInfo_C member_info_c = (NIMSignalingMemberInfo_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingMemberInfo_C));
NIMSignalingMemberInfo member_info = SignalHelper.NIMSignalingMemberFromC(member_info_c);
res_param.info_.members_.Add(member_info);
}
NimUtility.DelegateConverter.Invoke <NimSignalingOptJoinHandler>(user_data, code, res_param);
}
public void UTSignalHelperAbsoluteToRelativePosition4()
{
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(2, 4, 6),
4
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(4, -4, 6),
2
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(-10, 4, 6),
4
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(18, 6, 6),
0
);
}
public void UTSignalHelperAbsoluteToRelativePosition1()
{
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(2),
2
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(4, 0),
4
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(8, 0),
8
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(12, 0, 0),
12
);
}
public void UTSignalHelperAbsoluteToRelativePosition2()
{
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(2, 2),
0
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(4, 3),
1
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(8, 10),
-2
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(12, 6, 0),
6
);
}
public void UTSignalHelperAbsoluteToRelativePosition3()
{
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(2, loopLength: 6),
2
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(4, loopLength: 3),
1
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(-10, loopLength: 6),
2
);
Assert.AreEqual(
SignalHelper.AbsoluteToRelativePosition(12, 0, 6),
0
);
}
private static void NimSignalingMembersSyncCallback(IntPtr detailed_info, IntPtr user_data)
{
NIMSignalingChannelDetailedinfo channel_detailed_info = new NIMSignalingChannelDetailedinfo();
if (detailed_info != IntPtr.Zero)
{
NIMSignalingChannelDetailedinfo_C res_param = (NIMSignalingChannelDetailedinfo_C)Marshal.PtrToStructure(detailed_info, typeof(NIMSignalingChannelDetailedinfo_C));
channel_detailed_info.channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(res_param.channel_info_);
for (int i = 0; i < res_param.member_size_; i++)
{
IntPtr src_data = NimUtility.IntPtrExtensions.Increment(res_param.members_, i * Marshal.SizeOf(typeof(NIMSignalingMemberInfo)));
NIMSignalingMemberInfo member_info = (NIMSignalingMemberInfo)Marshal.PtrToStructure(src_data, typeof(NIMSignalingMemberInfo));
channel_detailed_info.members_.Add(member_info);
}
}
NimUtility.DelegateConverter.Invoke <NimSignalingMembersSyncHandler>(user_data, channel_detailed_info);
}
private static NIMSignalingNotityInfo NotityInfoFromIntPtr(IntPtr src_data)
{
NIMSignalingNotityInfo_C info_c = (NIMSignalingNotityInfo_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingNotityInfo_C));
NIMSignalingNotityInfo info = null;
object notity_objtect = null;
switch (info_c.event_type_)
{
case NIMSignalingEventType.kNIMSignalingEventTypeClose:
case NIMSignalingEventType.kNIMSignalingEventTypeLeave:
case NIMSignalingEventType.kNIMSignalingEventTypeCtrl:
notity_objtect = info_c;
info = SignalHelper.NIMSignalingNotityInfoFromC(info_c);
break;
case NIMSignalingEventType.kNIMSignalingEventTypeJoin:
notity_objtect = (NIMSignalingNotityInfoJoin_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingNotityInfoJoin_C));
info = SignalHelper.NIMSignalingNotityInfoFromC((NIMSignalingNotityInfoJoin_C)notity_objtect);
break;
case NIMSignalingEventType.kNIMSignalingEventTypeInvite:
notity_objtect = (NIMSignalingNotityInfoInvite_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingNotityInfoInvite_C));
info = SignalHelper.NIMSignalingNotityInfoFromC((NIMSignalingNotityInfoInvite_C)notity_objtect);
break;
case NIMSignalingEventType.kNIMSignalingEventTypeCancelInvite:
notity_objtect = (NIMSignalingNotityInfoCancelInvite_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingNotityInfoCancelInvite_C));
info = SignalHelper.NIMSignalingNotityInfoFromC((NIMSignalingNotityInfoCancelInvite_C)notity_objtect);
break;
case NIMSignalingEventType.kNIMSignalingEventTypeReject:
notity_objtect = (NIMSignalingNotityInfoReject_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingNotityInfoReject_C));
info = SignalHelper.NIMSignalingNotityInfoFromC((NIMSignalingNotityInfoReject_C)notity_objtect);
break;
case NIMSignalingEventType.kNIMSignalingEventTypeAccept:
notity_objtect = (NIMSignalingNotityInfoAccept_C)Marshal.PtrToStructure(src_data, typeof(NIMSignalingNotityInfoAccept_C));
info = SignalHelper.NIMSignalingNotityInfoFromC((NIMSignalingNotityInfoAccept_C)notity_objtect);
break;
}
return(info);
}
public void Run(IBackgroundTaskInstance taskInstance)
{
SignalFileLoggerProvider.ForceAddBGLog(LibUtils.GetBGStartMessage());
SignalLogging.SetupLogging(false);
Deferral = taskInstance.GetDeferral();
ToastNotifier = ToastNotificationManager.CreateToastNotifier();
taskInstance.Canceled += OnCanceled;
bool locked = LibUtils.Lock(5000);
Logger.LogTrace("Locking global finished, locked = {0}", locked);
if (!locked)
{
Logger.LogWarning("App is running, background task shutting down");
Deferral.Complete();
return;
}
GlobalResetEvent = LibUtils.OpenResetEventUnset();
Task.Run(() =>
{
GlobalResetEvent.WaitOne();
Logger.LogInformation("Background task received app startup signal");
ResetEvent.Set();
});
try
{
Handle = SignalHelper.CreateSignalLibHandle(true);
Handle.SignalMessageEvent += Handle_SignalMessageEvent;
Handle.BackgroundAcquire();
ResetEvent.WaitOne();
}
catch (Exception e)
{
Logger.LogError("Background task failed: {0}\n{1}", e.Message, e.StackTrace);
}
finally
{
Logger.LogInformation("Background task shutting down");
Handle.BackgroundRelease();
LibUtils.Unlock();
Deferral.Complete();
}
}
/// <summary>
/// 独立信令 创建频道
/// 该接口用户创建频道，同一时刻频道名互斥，不能重复创建。但如果频道名缺省，服务器会自动分配频道id。
/// 对于频道在创建后如果没人加入，有效期2小时，当有成员加入后会自动延续频道有效期。当主动关闭频道或者最后一个成员退出后2小时后频道销毁。
/// </summary>
/// <param name="param">创建频道的传入参数</param>
/// <param name="cb">结果回调见NimSignalingDef.cs</param>
public static void SignalingCreate(NIMSignalingCreateParam param, NimSignalingOptCreateHandler cb)
{
NIMSignalingCreateParam_C param_c = SignalHelper.GetNativeNIMSignalingCreateParam(param);
int nSizeOfParam = Marshal.SizeOf(param_c);
IntPtr param_ptr = Marshal.AllocHGlobal(nSizeOfParam);
try
{
Marshal.StructureToPtr(param_c, param_ptr, false);
var user_ptr = NimUtility.DelegateConverter.ConvertToIntPtr(cb);
SignalingNativeMethods.nim_signaling_create(param_ptr, NimSignalingCreateCb, user_ptr);
}
catch (Exception ex)
{
}
finally
{
Marshal.FreeHGlobal(param_ptr);
}
}
public void SetData(IntPtr ptr)
{
if (ptr == IntPtr.Zero)
{
return;
}
ChannelDetail channelDetail = (ChannelDetail)Marshal.PtrToStructure(ptr, typeof(ChannelDetail));
NIMSignalingChannelInfo_C channel = (NIMSignalingChannelInfo_C)Marshal.PtrToStructure(channelDetail.Channel, typeof(NIMSignalingChannelInfo_C));
channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(channel);
if (channelDetail.MembersCount > 0)
{
for (int i = 0; i < channelDetail.MembersCount; i++)
{
var memberPtr = Marshal.ReadIntPtr(channelDetail.Members, i * Marshal.SizeOf(typeof(IntPtr)));
var member = (NIMSignalingMemberInfo)Marshal.PtrToStructure(memberPtr, typeof(NIMSignalingMemberInfo));
members_.Add(member);
}
}
}
// todo Abundant Music WebAudioPlayer has synthesis settings. How did it do the percussion?
private DiscreteSignal GetPercussionSignal(PercussionType percussionType, int sampleCount)
{
switch (percussionType)
{
// Bass drums
case PercussionType.Bass:
var bass = SignalHelper.GetChirp(90, 120, sampleCount);
var bass2 = SignalHelper.GetChirp(180, 240, sampleCount);
var bass3 = SignalHelper.GetChirp(270, 360, sampleCount);
// The chirp builder goes in the "up" direction, so we need to reverse it to go "down"
bass = new DiscreteSignal(Constants.SAMPLE_RATE, bass.Samples.Reverse());
bass2 = new DiscreteSignal(Constants.SAMPLE_RATE, bass2.Samples.Reverse());
bass3 = new DiscreteSignal(Constants.SAMPLE_RATE, bass3.Samples.Reverse());
// Combine the two bass signals so that the bass has more "presence"
bass = bass.Superimpose(bass2).Superimpose(bass3);
return(bass);
// Snare drums
case PercussionType.Snare:
var snare = SignalHelper.GetKarplusStrongDrum(0.5, 30, 1, 1, sampleCount);
return(snare);
// Crash drums
case PercussionType.Crash:
var crash = SignalHelper.GetKarplusStrongDrum(0.5, 11, 1, 1, sampleCount);
return(crash);
// Ride drums
case PercussionType.Ride:
// Defaulting to a ride drum probably isn't good, but it will sound in lots of situations.
default:
var ride = SignalHelper.GetKarplusStrongDrum(0.5, 60, 0.1, 1, sampleCount);
return(ride);
}
}
/// <summary>
/// 独立信令 用户自定义控制指令接口
/// 该接口用于在频道中透传一些自定义指令，协助频道管理
/// </summary>
/// <param name="param">控制通知的传入参数，接收方to_填空为群发，只支持在线通知</param>
/// <param name="cb">结果回调见NimSignalingDef.cs</param>
public static void Control(NIMSignalingControlParam param, NimSignalingOptControlHandler cb)
{
NIMSignalingControlParam_C param_c = SignalHelper.GetNativeNIMSignalingControlParam(param);
int nSizeOfParam = Marshal.SizeOf(param_c);
IntPtr param_ptr = Marshal.AllocHGlobal(nSizeOfParam);
try
{
Marshal.StructureToPtr(param_c, param_ptr, false);
var user_ptr = NimUtility.DelegateConverter.ConvertToIntPtr(cb);
SignalingNativeMethods.nim_signaling_control(param_ptr, NimSignalingControlCb, user_ptr);
}
catch (Exception)
{
cb?.Invoke(NIMSignalingControlResCode.kAbnormal);
}
finally
{
Marshal.FreeHGlobal(param_ptr);
}
}
/// <summary>
/// 独立信令 接受邀请接口
/// 不开自动加入开关：该接口只接受邀请并告知邀请者，并同步通知自己的其他在线设备，但不会主动加入频道，需要单独调用加入接口
/// 打开自动加入开关：该接口为组合接口，等同于先调用接受邀请，成功后再加入频道。
/// 该接口在打开自动加入开关后是组合接口，对应的通知会有2个，接收邀请通知和加入通知
/// </summary>
/// <param name="param">接受邀请的传入参数</param>
/// <param name="cb">结果回调见NimSignalingDef.cs，其中opt_res_param在打开自动加入开关，并成功后有效</param>
public static void Accept(NIMSignalingAcceptParam param, NimSignalingOptAcceptHandler cb)
{
NIMSignalingAcceptParam_C param_c = SignalHelper.GetNativeNIMSignalingAcceptParam(param);
int nSizeOfParam = Marshal.SizeOf(param_c);
IntPtr param_ptr = Marshal.AllocHGlobal(nSizeOfParam);
try
{
Marshal.StructureToPtr(param_c, param_ptr, false);
var user_ptr = NimUtility.DelegateConverter.ConvertToIntPtr(cb);
SignalingNativeMethods.nim_signaling_accept(param_ptr, NimSignalingAcceptCb, user_ptr);
}
catch (Exception)
{
if (cb != null)
{
cb.Invoke(NIMSignalingRejectOrAcceptResCode.kAbnormal, null);
}
}
finally
{
Marshal.FreeHGlobal(param_ptr);
}
}
private static void NimSignalingOptJoinCallback(int code, IntPtr opt_res_param, IntPtr user_data)
{
NIMSignalingJoinResParam res_param = new NIMSignalingJoinResParam();
if (code == (int)NIM.ResponseCode.kNIMResSuccess)
{
res_param = new NIMSignalingJoinResParam();
JoinResult result = (JoinResult)Marshal.PtrToStructure(opt_res_param, typeof(JoinResult));
ChannelDetail channelDetail = (ChannelDetail)Marshal.PtrToStructure(result.DetailInfo, typeof(ChannelDetail));
NIMSignalingChannelInfo_C channel = (NIMSignalingChannelInfo_C)Marshal.PtrToStructure(channelDetail.Channel, typeof(NIMSignalingChannelInfo_C));
if (channelDetail.MembersCount > 0)
{
NIMSignalingMemberInfo[] members = new NIMSignalingMemberInfo[channelDetail.MembersCount];
for (int i = 0; i < channelDetail.MembersCount; i++)
{
var ptr = Marshal.ReadIntPtr(channelDetail.Members, i * Marshal.SizeOf(typeof(IntPtr)));
members[i] = (NIMSignalingMemberInfo)Marshal.PtrToStructure(ptr, typeof(NIMSignalingMemberInfo));
}
res_param.info_.members_.AddRange(members);
}
res_param.info_.channel_info_ = SignalHelper.NIMSignalingChannelInfoFromC(channel);
}
NimUtility.DelegateConverter.Invoke <NimSignalingOptJoinHandler>(user_data, code, res_param);
}
public override void OnComplete()
{
Complete(SignalHelper.Complete <T>());
}
public override void OnNext(T t)
{
produced++;
actual.OnNext(SignalHelper.Next(t));
}
public ActionResult getAllRoom(string sortOrder, string selectedBlock = "", string selectedType = "", string selectedRoomNum = "")
{
var roomsStatusChangedCount = 0;
List <Helper.MySQlRoom> res = MysqlFetchingRoomData.getDataFromMySql();
foreach (var item in res)
{
var room = _roomService.GetAll().Where(x => x.RoomNum == item.RoomNum).FirstOrDefault();
if (room != null)
{
room.IsNeedfix = item.MantStatus == "M" ? true : false;
room.isneedclean = item.CleanStatus == "D" ? true : false;
if (room.IsNeedfix && !room.Isrequistedfix)
{
roomsStatusChangedCount++;
}
if (room.isneedclean && !room.Isrequisted)
{
roomsStatusChangedCount++;
}
_roomService.Edit(room);
}
}
List <RoomDto> list1 = _roomService.GetAll();
List <RoomDto> list2 = new List <RoomDto>();
foreach (var item in list1)
{
item.TypeName = _roomTypeService.getbyidGetById(item.RoomType_id).Name.ToString();
item.blockName = _hotelBlockService.GetById(item.HotelBlock_id).BlockName.ToString();
list2.Add(item);
}
var RF = new RoomFilter();
RF.HotelBlocks = _hotelBlockService.GetAll().Select(x => new SelectListItem()
{
Value = x.Id.ToString(),
Text = x.BlockName
});
RF.Types = _roomTypeService.GetRoomTypes().Select(x => new SelectListItem()
{
Value = x.Id.ToString(),
Text = x.Name
});
var data = list2;
roomsStatusChangedCount = data.Where(x => (x.isneedclean && !x.Isrequisted) || x.IsNeedfix && !x.Isrequistedfix).Count();
System.Web.HttpContext.Current.Session["roomsStatusChangedCount"] = roomsStatusChangedCount;
SignalHelper.SendRoomsStatusChangedCount(roomsStatusChangedCount);
var selectedTypeValue = 0;
var isInt = int.TryParse(selectedBlock, out selectedTypeValue);
if (!string.IsNullOrEmpty(selectedBlock) && isInt)
{
data = data.Where(f => f.HotelBlock_id == (int)int.Parse(selectedBlock)).ToList();
}
if (!string.IsNullOrEmpty(selectedRoomNum))
{
data = data.Where(f => f.RoomNum == selectedRoomNum).ToList();
}
selectedTypeValue = 0;
isInt = int.TryParse(selectedType, out selectedTypeValue);
if (!string.IsNullOrEmpty(selectedType) && isInt)
{
data = data.Where(f => f.RoomType_id == (int)int.Parse(selectedType)).ToList();
}
ViewBag.RoomNumberSortParm = !String.IsNullOrEmpty(sortOrder) ? "number_desc" : "number";
ViewBag.RoomDirSortParm = !String.IsNullOrEmpty(sortOrder) ? "dir_desc" : "dir";
ViewBag.RoomBlockSortParm = !String.IsNullOrEmpty(sortOrder) ? "block_desc" : "block";
ViewBag.RoomTypeSortParm = !String.IsNullOrEmpty(sortOrder) ? "type_desc" : "type";
ViewBag.RoomIsBusySortParm = !String.IsNullOrEmpty(sortOrder) ? "busy_desc" : "busy";
ViewBag.RoomIsNeedFixSortParm = !String.IsNullOrEmpty(sortOrder) ? "fix_desc" : "fix";
ViewBag.RoomIsNeedCleanSortParm = !String.IsNullOrEmpty(sortOrder) ? "clean_desc" : "clean";
ViewBag.RoomIsInServiceSortParm = !String.IsNullOrEmpty(sortOrder) ? "service_desc" : "service";
switch (sortOrder)
{
case "number_desc":
data = data.OrderByDescending(s => s.RoomNum).ToList();
break;
case "dir_desc":
data = data.OrderByDescending(s => s.RoomDirection).ToList();
break;
case "block_desc":
data = data.OrderByDescending(s => s.blockName).ToList();
break;
case "type_desc":
data = data.OrderByDescending(s => s.TypeName).ToList();
break;
case "busy_desc":
data = data.OrderByDescending(s => s.Isbusy).ToList();
break;
case "fix_desc":
data = data.OrderByDescending(s => s.IsNeedfix).ToList();
break;
case "clean_desc":
data = data.OrderByDescending(s => s.isneedclean).ToList();
break;
case "service_desc":
data = data.OrderByDescending(s => s.IsInService).ToList();
break;
case "number":
data = data.OrderBy(s => s.RoomNum).ToList();
break;
case "dir":
data = data.OrderBy(s => s.RoomDirection).ToList();
break;
case "block":
data = data.OrderBy(s => s.blockName).ToList();
break;
case "type":
data = data.OrderBy(s => s.TypeName).ToList();
break;
case "busy":
data = data.OrderBy(s => s.Isbusy).ToList();
break;
case "fix":
data = data.OrderBy(s => s.IsNeedfix).ToList();
break;
case "clean":
data = data.OrderBy(s => s.isneedclean).ToList();
break;
case "service":
data = data.OrderBy(s => s.IsInService).ToList();
break;
}
RF.Data = data.ToList();
return(View(RF));
}
//al hacer miVariable = Wave.Offset ejecutamos get
//al hacer Wave.Offset = 5 ejecutamos set
//ENDOF Implementación ISignalContent
//Implementación ISignalHandler
bool ISignalHandler.HasValuesAt(int position, uint loopLength, bool recursive)
{
//return true if this value's individual offset equals target position
return(SignalHelper.AbsoluteToRelativePosition(position, _offset, loopLength) == 0);
}
//private static void _SetupRefreshJob()
//{
// //remove a previous job
// Action remove = HttpContext.Current.Cache["Refresh"] as Action;
// if (remove is Action)
// {
// HttpContext.Current.Cache.Remove("Refresh");
// remove.EndInvoke(null);
// }
// //get the worker
// Action work = () => {
// while (true)
// {
// Thread.Sleep(60000);
// WebClient refresh = new WebClient();
// try
// {
// refresh.UploadString("http://salesapp.ssg-sy.com", string.Empty);
// refresh.UploadString("http://salesapp.ssg-sy.com/remote", string.Empty);
// }
// catch (Exception ex)
// {
// //snip...
// }
// finally
// {
// refresh.Dispose();
// }
// }
// };
// work.BeginInvoke(null, null);
// //add this job to the cache
// HttpContext.Current.Cache.Add(
// "Refresh",
// work,
// null,
// Cache.NoAbsoluteExpiration,
// Cache.NoSlidingExpiration,
// CacheItemPriority.Normal,
// (s, o, r) => { _SetupRefreshJob(); }
// );
//}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
// Initialize Mapper
DtoMappings.Initialize();
//Initialise Bootstrapper
Bootstrapper.Initialise();
FluentValidationModelValidatorProvider.Configure(
provider =>
{
provider.ValidatorFactory = new DependencyResolverModelValidatorFactory();
provider.Add(
typeof(IsEmailUniquePropertyValidator),
(metadata, context, rule, validator) => new IsEmailUniqueClientPropertyValidator(metadata, context, rule, validator));
/// GuideCity ///
// provider.Add(
// typeof(GuideIsArabicNameAddUniquePropertyValidator),
// (metadata, context, rule, validator) => new GuideIsArabicNameAddUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(GuideIsEnglishNameAddUniquePropertyValidator),
// (metadata, context, rule, validator) => new GuideIsEnglishNameAddUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(GuideIsArabicNameEditUniquePropertyValidator),
// (metadata, context, rule, validator) => new GuideIsArabicNameEditUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(GuideIsEnglishNameEditUniquePropertyValidator),
// (metadata, context, rule, validator) => new GuideIsEnglishNameEditUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
//typeof(GuideIsExistIdEditUniquePropertyValidator),
//(metadata, context, rule, validator) => new GuideIsExistIdEditUniqueClientPropertyValidator(metadata, context, rule, validator));
//// provider.Add(
//typeof(GuideIsCityIdExistPropertyValidator),
//(metadata, context, rule, validator) => new GuideIsCityIdExistClientPropertyValidator(metadata, context, rule, validator));
/// GuideTown ///
// provider.Add(
// typeof(GuideIsIdExistTownPropertyValidator),
// (metadata, context, rule, validator) => new GuideIsIdExistTownClientPropertyValidator(metadata, context, rule, validator));
//// provider.Add(
//typeof(GuideIsCityIdExistPropertyValidator),
//(metadata, context, rule, validator) => new GuideIsCityIdExistClientPropertyValidator(metadata, context, rule, validator));
/// City ///
// provider.Add(
// typeof(IsArabicNameAddUniquePropertyValidator),
// (metadata, context, rule, validator) => new IsArabicNameAddUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(IsEnglishNameAddUniquePropertyValidator),
// (metadata, context, rule, validator) => new IsEnglishNameAddUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(IsArabicNameEditUniquePropertyValidator),
// (metadata, context, rule, validator) => new IsArabicNameEditUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(IsEnglishNameEditUniquePropertyValidator),
// (metadata, context, rule, validator) => new IsEnglishNameEditUniqueClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(IsExistIdEditUniquePropertyValidator),
//(metadata, context, rule, validator) => new IsExistIdEditUniqueClientPropertyValidator(metadata, context, rule, validator));
/// Town ///
//provider.Add(
// typeof(IsCityIdExistPropertyValidator),
//(metadata, context, rule, validator) => new IsCityIdExistClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(IsIdExistTownPropertyValidator),
//(metadata, context, rule, validator) => new IsIdExistTownClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(IsPlaceIdUniqueAddPropertyValidator),
//(metadata, context, rule, validator) => new IsPlaceIdUniqueAddClientPropertyValidator(metadata, context, rule, validator));
// provider.Add(
// typeof(IsPlaceIdUniqueEditPropertyValidator),
//(metadata, context, rule, validator) => new IsPlaceIdUniqueEditClientPropertyValidator(metadata, context, rule, validator));
/// Classify ///
});
AntiForgeryConfig.SuppressIdentityHeuristicChecks = true;
//SignalR start for notifications
SignalHelper.Start();
}
public override void OnError(Exception e)
{
Complete(SignalHelper.Error <T>(e));
}
