Exemplo n.º 1
0
        public async Task <bool> RegisterUnit(PushUri pushUri)
        {
            string deviceId = pushUri.DeviceId.GetHashCode().ToString();
            List <PushRegistrationDescription> usersDevices = null;

            try
            {
                usersDevices = await _unitNotificationProvider.GetRegistrationsByUUID(pushUri.PushLocation);
            }
            catch (TimeoutException)
            { }


            if (usersDevices == null || !usersDevices.Any(x => x.Tags.Contains(string.Format("unitId:{0}", pushUri.UnitId.ToString()))))
            {
                await _unitNotificationProvider.RegisterPush(pushUri);
            }
            else
            {
                await _unitNotificationProvider.UnRegisterPushByUUID(pushUri.PushLocation);

                await _unitNotificationProvider.RegisterPush(pushUri);
            }

            return(true);
        }
Exemplo n.º 2
0
        public async Task UnRegisterPushByUserDeviceId(PushUri pushUri)
        {
            var hubClient = NotificationHubClient.CreateClientFromConnectionString(Config.ServiceBusConfig.AzureNotificationHub_FullConnectionString, Config.ServiceBusConfig.AzureNotificationHub_PushUrl);

            var registrations = await hubClient.GetRegistrationsByTagAsync(string.Format("userId:{0}", pushUri.UserId), 50);

            // Step 1: Remove the devices that have a hashed deviceId
            try
            {
                List <Task> tasksWithHashedDeviceId = registrations.Where(x => x.Tags.Contains(pushUri.DeviceId.GetHashCode().ToString())).Select(registration => hubClient.DeleteRegistrationAsync(registration)).ToList();
                await Task.WhenAll(tasksWithHashedDeviceId.ToArray());
            }
            catch { }

            // Step 2: Remove the devices that have a non-hashsed device id (the old style)
            try
            {
                List <Task> tasksWithNormalDeviceId = registrations.Where(x => x.Tags.Contains(pushUri.DeviceId)).Select(registration => hubClient.DeleteRegistrationAsync(registration)).ToList();
                await Task.WhenAll(tasksWithNormalDeviceId.ToArray());
            }
            catch { }

            // Step 3: Remove the devices that have that PushUriId
            try
            {
                List <Task> tasksWithHashedDeviceId = registrations.Where(x => x.Tags.Contains(string.Format("pushUriId:{0}", pushUri.PushUriId))).Select(registration => hubClient.DeleteRegistrationAsync(registration)).ToList();
                await Task.WhenAll(tasksWithHashedDeviceId.ToArray());
            }
            catch (Exception ex)
            {
                Framework.Logging.LogException(ex, string.Format("PushUriId: {0}", pushUri.PushUriId));
            }
        }
Exemplo n.º 3
0
        public async Task <bool> Register(PushUri pushUri)
        {
            if (pushUri == null || String.IsNullOrWhiteSpace(pushUri.DeviceId))
            {
                return(false);
            }

            string deviceId = pushUri.DeviceId.GetHashCode().ToString();

            // We just store the full Device Id in the PushUri object, the hashed version is for Azure
            //var existingPushUri = _pushUriService.GetPushUriByPlatformDeviceId((Platforms)pushUri.PlatformType, pushUri.DeviceId);
            List <PushRegistrationDescription> usersDevices = null;

            try
            {
                usersDevices = await _notificationProvider.GetRegistrationsByUserId(pushUri.UserId);
            }
            catch (TimeoutException)
            { }


            //if (existingPushUri == null)
            //	pushUri = _pushUriService.SavePushUri(pushUri);

            if (usersDevices == null || !usersDevices.Any(x => x.Tags.Contains(deviceId)))
            {
                await _notificationProvider.RegisterPush(pushUri);
            }

            return(true);
        }
Exemplo n.º 4
0
        public async Task <bool> UnRegisterUnit(PushUri pushUri)
        {
            await _unitNotificationProvider.UnRegisterPushByUserDeviceId(pushUri);

            _pushUriService.DeleteAllPushUrisByPlatformDevice((Platforms)pushUri.PlatformType, pushUri.DeviceId);

            return(true);
        }
Exemplo n.º 5
0
        public async Task <ActionResult <DeviceRegistrationResult> > RegisterDevice([FromBody] DeviceRegistrationInput registrationInput, CancellationToken cancellationToken)
        {
            if (this.ModelState.IsValid)
            {
                var result = new DeviceRegistrationResult();

                try
                {
                    if (registrationInput == null)
                    {
                        return(BadRequest());
                    }

                    var push = new PushUri();
                    push.UserId       = UserId;
                    push.PlatformType = registrationInput.Plt;

                    if (!String.IsNullOrWhiteSpace(registrationInput.Uri))
                    {
                        push.PushLocation = HttpUtility.UrlDecode(registrationInput.Uri);
                    }
                    else if (registrationInput.Plt == (int)Platforms.Android)
                    {
                        push.PushLocation = "Android";
                    }
                    else if (registrationInput.Plt == (int)Platforms.iPhone || registrationInput.Plt == (int)Platforms.iPad)
                    {
                        push.PushLocation = "Apple";
                    }

                    push.DeviceId     = registrationInput.Did;
                    push.Uuid         = registrationInput.Id;
                    push.DepartmentId = DepartmentId;

                    CqrsEvent registerUnitPushEvent = new CqrsEvent();
                    registerUnitPushEvent.Type = (int)CqrsEventTypes.PushRegistration;
                    registerUnitPushEvent.Data = ObjectSerialization.Serialize(push);

                    await _cqrsProvider.EnqueueCqrsEventAsync(registerUnitPushEvent);

                    result.Sfl = true;
                    result.Id  = push.PushUriId;

                    return(result);
                }
                catch (Exception ex)
                {
                    result.Sfl = false;
                    Framework.Logging.LogException(ex);

                    return(result);
                }
            }

            return(BadRequest());
        }
Exemplo n.º 6
0
        public PushUri SavePushUri(PushUri pushUri)
        {
            if (pushUri.PushUriId == 0)
            {
                var uri = GetPushUriByPlatformDeviceId((Platforms)pushUri.PlatformType, pushUri.DeviceId);

                if (uri != null)
                {
                    return(uri);
                }
            }

            pushUri.CreatedOn = DateTime.UtcNow;
            _pushUriRepository.SaveOrUpdate(pushUri);

            return(pushUri);
        }
Exemplo n.º 7
0
        public async Task UnRegisterPush(PushUri pushUri)
        {
            var hubClient = NotificationHubClient.CreateClientFromConnectionString(Config.ServiceBusConfig.AzureNotificationHub_FullConnectionString, Config.ServiceBusConfig.AzureNotificationHub_PushUrl);

            var registrations = await hubClient.GetRegistrationsByTagAsync(string.Format("userId:{0}", pushUri.UserId), 50);

            foreach (var registration in registrations)
            {
                if (pushUri.PlatformType == (int)Platforms.Windows8 ||
                    pushUri.PlatformType == (int)Platforms.WindowsPhone7 ||
                    pushUri.PlatformType == (int)Platforms.WindowsPhone8)
                {
                    var winReg = registration as WindowsRegistrationDescription;
                    if (winReg != null && winReg.ChannelUri == pushUri.ChannelUri)
                    {
                        await hubClient.DeleteRegistrationAsync(registration);
                    }
                }
                else if (pushUri.PlatformType == (int)Platforms.Android)
                {
                    var androidReg = registration as GcmRegistrationDescription;
                    if (androidReg != null && androidReg.GcmRegistrationId == pushUri.DeviceId)
                    {
                        await hubClient.DeleteRegistrationAsync(registration);
                    }
                }
                else if (pushUri.PlatformType == (int)Platforms.iPad || pushUri.PlatformType == (int)Platforms.iPhone)
                {
                    var iosReg = registration as AppleRegistrationDescription;
                    if (iosReg != null && iosReg.DeviceToken == pushUri.DeviceId)
                    {
                        await hubClient.DeleteRegistrationAsync(registration);
                    }
                }
            }
        }
Exemplo n.º 8
0
        public async Task RegisterPush(PushUri pushUri)
        {
            if (String.IsNullOrWhiteSpace(pushUri.DeviceId))
            {
                return;
            }

            var hubClient = NotificationHubClient.CreateClientFromConnectionString(Config.ServiceBusConfig.AzureNotificationHub_FullConnectionString, Config.ServiceBusConfig.AzureNotificationHub_PushUrl);
            var tagsWithHashedDeviceId = new List <string>(new string[] { string.Format("userId:{0}", pushUri.UserId),
                                                                          string.Format("platform:{0}", pushUri.PlatformType),
                                                                          string.Format("deviceId:{0}", pushUri.DeviceId.GetHashCode()) });

            if (pushUri.DepartmentId > 0)
            {
                tagsWithHashedDeviceId.Add(string.Format("departmentId:{0}", pushUri.DepartmentId));
            }

            CollectionQueryResult <RegistrationDescription> registrations = null;

            try
            {
                registrations = hubClient.GetRegistrationsByTagAsync(string.Format("deviceId:{0}", pushUri.DeviceId.GetHashCode()), 50).Result;
            }
            catch
            {
                // So this just fails, like whenever it wants. I would rather people get 2 or 3 push messages for a fire then none.
            }

            // Loop through all Azure registrations for this Hashed DeviceId and remove them
            if (registrations != null)
            {
                foreach (var registration in registrations)
                {
                    try
                    {
                        await hubClient.DeleteRegistrationAsync(registration);
                    }
                    catch (Exception ex)
                    {
                        Framework.Logging.LogException(ex);
                    }
                }
            }

            if (pushUri.PlatformType == (int)Platforms.WindowsPhone7 || pushUri.PlatformType == (int)Platforms.WindowsPhone8)
            {
                try
                {
                    var result = await hubClient.CreateMpnsNativeRegistrationAsync(pushUri.PushLocation, tagsWithHashedDeviceId.ToArray());
                }
                catch (ArgumentException ex)
                {
                    Framework.Logging.LogException(ex,
                                                   string.Format("Device Information: {0} {1} {2} {3}", tagsWithHashedDeviceId[0], tagsWithHashedDeviceId[1],
                                                                 tagsWithHashedDeviceId[2], tagsWithHashedDeviceId[3]));
                }
            }
            else if (pushUri.PlatformType == (int)Platforms.Windows8)
            {
                try
                {
                    var result = await hubClient.CreateWindowsNativeRegistrationAsync(pushUri.PushLocation, tagsWithHashedDeviceId.ToArray());
                }
                catch (ArgumentException ex)
                {
                    Framework.Logging.LogException(ex,
                                                   string.Format("Device Information: {0} {1} {2} {3}", tagsWithHashedDeviceId[0], tagsWithHashedDeviceId[1],
                                                                 tagsWithHashedDeviceId[2], tagsWithHashedDeviceId[3]));
                }
            }
            else if (pushUri.PlatformType == (int)Platforms.Android)
            {
                try
                {
                    var result = await hubClient.CreateGcmNativeRegistrationAsync(pushUri.DeviceId, tagsWithHashedDeviceId.ToArray());
                }
                catch (ArgumentException ex)
                {
                    Framework.Logging.LogException(ex,
                                                   string.Format("Device Information: {0} {1} {2} {3}", tagsWithHashedDeviceId[0], tagsWithHashedDeviceId[1],
                                                                 tagsWithHashedDeviceId[2], tagsWithHashedDeviceId[3]));
                }
            }
            else if (pushUri.PlatformType == (int)Platforms.iPad || pushUri.PlatformType == (int)Platforms.iPhone)
            {
                try
                {
                    var result = await hubClient.CreateAppleNativeRegistrationAsync(pushUri.DeviceId, tagsWithHashedDeviceId.ToArray());
                }
                catch (ArgumentException ex)
                {
                    Framework.Logging.LogException(ex,
                                                   string.Format("Device Information: {0} {1} {2} {3}", tagsWithHashedDeviceId[0], tagsWithHashedDeviceId[1],
                                                                 tagsWithHashedDeviceId[2], tagsWithHashedDeviceId[3]));
                }
            }
        }
Exemplo n.º 9
0
 public void DeletePushUri(PushUri pushUri)
 {
     _pushUriRepository.DeleteOnSubmit(pushUri);
 }
Exemplo n.º 10
0
        public async Task RegisterPush(PushUri pushUri)
        {
            if (String.IsNullOrWhiteSpace(pushUri.DeviceId))
            {
                return;
            }

            if (pushUri.UnitId.HasValue)
            {
                var hubClient = NotificationHubClient.CreateClientFromConnectionString(Config.ServiceBusConfig.AzureUnitNotificationHub_FullConnectionString, Config.ServiceBusConfig.AzureUnitNotificationHub_PushUrl);
                var unitTags  = new string[]
                {
                    string.Format("pushUriId:{0}", pushUri.PushUriId),
                    string.Format("deviceId:{0}", pushUri.DeviceId.GetHashCode()),                     // Device Id is the registration token
                    string.Format("unitId:{0}", pushUri.UnitId),
                    string.Format("uuid:{0}", pushUri.PushLocation),
                    string.Format("did:{0}", pushUri.DepartmentId)
                };

                CollectionQueryResult <RegistrationDescription> registrations = null;
                try
                {
                    registrations = await hubClient.GetRegistrationsByTagAsync(string.Format("deviceId:{0}", pushUri.DeviceId.GetHashCode()), 50);
                }
                catch
                {
                    // So this just fails, like whenever it wants. I would rather people get 2 or 3 push messages for a fire then none.
                }

                // Loop through all Azure registrations for this Hashed DeviceId and remove them
                if (registrations != null)
                {
                    foreach (var registration in registrations)
                    {
                        try
                        {
                            await hubClient.DeleteRegistrationAsync(registration);
                        }
                        catch (Exception ex)
                        {
                            Framework.Logging.LogException(ex);
                        }
                    }
                }

                if (pushUri.PlatformType == (int)Platforms.UnitWin)
                {
                    try
                    {
                        var result = await hubClient.CreateMpnsNativeRegistrationAsync(pushUri.PushLocation, unitTags);
                    }
                    catch (ArgumentException ex)
                    {
                    }
                }
                else if (pushUri.PlatformType == (int)Platforms.UnitAndroid)
                {
                    try
                    {
                        var result = await hubClient.CreateFcmNativeRegistrationAsync(pushUri.DeviceId, unitTags);
                    }
                    catch (ArgumentException ex)
                    {
                    }
                }
                else if (pushUri.PlatformType == (int)Platforms.UnitIOS)
                {
                    try
                    {
                        var result = await hubClient.CreateAppleNativeRegistrationAsync(pushUri.DeviceId, unitTags);
                    }
                    catch (ArgumentException ex)
                    {
                    }
                }
            }
        }
Exemplo n.º 11
0
        public static bool ProcessSystemQueueItem(CqrsEvent qi)
        {
            bool success = true;

            if (qi != null)
            {
                switch ((CqrsEventTypes)qi.Type)
                {
                case CqrsEventTypes.None:
                    break;

                case CqrsEventTypes.UnitLocation:
                    UnitLocation unitLocation = null;
                    try
                    {
                        unitLocation = ObjectSerialization.Deserialize <UnitLocation>(qi.Data);
                    }
                    catch (Exception ex)
                    {
                    }

                    if (unitLocation != null)
                    {
                        IUnitsService unitService;
                        try
                        {
                            unitService = Bootstrapper.GetKernel().Resolve <IUnitsService>();
                            unitService.AddUnitLocation(unitLocation);
                        }
                        catch (Exception ex)
                        {
                        }
                        finally
                        {
                            unitService = null;
                        }
                    }
                    break;

                case CqrsEventTypes.PushRegistration:

                    PushUri data = null;
                    try
                    {
                        data = ObjectSerialization.Deserialize <PushUri>(qi.Data);
                    }
                    catch (Exception ex)
                    {
                    }

                    if (data != null)
                    {
                        var pushService     = Bootstrapper.GetKernel().Resolve <IPushService>();
                        var resgriterResult = pushService.Register(data).Result;

                        pushService = null;
                    }
                    break;

                case CqrsEventTypes.UnitPushRegistration:
                    PushRegisterionEvent unitData = null;
                    try
                    {
                        unitData = ObjectSerialization.Deserialize <PushRegisterionEvent>(qi.Data);
                    }
                    catch (Exception ex)
                    {
                    }

                    if (unitData != null)
                    {
                        PushUri pushUri = new PushUri();
                        pushUri.PushUriId    = unitData.PushUriId;
                        pushUri.UserId       = unitData.UserId;
                        pushUri.PlatformType = unitData.PlatformType;
                        pushUri.PushLocation = unitData.PushLocation;
                        pushUri.DepartmentId = unitData.DepartmentId;
                        pushUri.UnitId       = unitData.UnitId;
                        pushUri.DeviceId     = unitData.DeviceId;
                        pushUri.Uuid         = unitData.Uuid;

                        var pushService = Bootstrapper.GetKernel().Resolve <IPushService>();
                        var unitResult  = pushService.RegisterUnit(pushUri).Result;

                        pushService = null;
                    }
                    break;

                case CqrsEventTypes.StripeChargeSucceeded:
                    var succeededCharge = Stripe.Mapper <StripeCharge> .MapFromJson(qi.Data);

                    if (succeededCharge != null)
                    {
                        var paymentProviderService = Bootstrapper.GetKernel().Resolve <IPaymentProviderService>();

                        paymentProviderService.ProcessStripePayment(succeededCharge);
                    }
                    break;

                case CqrsEventTypes.StripeChargeFailed:
                    var failedCharge = Stripe.Mapper <StripeCharge> .MapFromJson(qi.Data);

                    if (failedCharge != null)
                    {
                        var paymentProviderService = Bootstrapper.GetKernel().Resolve <IPaymentProviderService>();

                        paymentProviderService.ProcessStripeChargeFailed(failedCharge);
                    }
                    break;

                case CqrsEventTypes.StripeChargeRefunded:
                    var refundedCharge = Stripe.Mapper <StripeCharge> .MapFromJson(qi.Data);

                    if (refundedCharge != null)
                    {
                        var paymentProviderService = Bootstrapper.GetKernel().Resolve <IPaymentProviderService>();

                        paymentProviderService.ProcessStripeSubscriptionRefund(refundedCharge);
                    }
                    break;

                case CqrsEventTypes.StripeSubUpdated:
                    var updatedSubscription = Stripe.Mapper <StripeSubscription> .MapFromJson(qi.Data);

                    if (updatedSubscription != null)
                    {
                        var paymentProviderService = Bootstrapper.GetKernel().Resolve <IPaymentProviderService>();

                        paymentProviderService.ProcessStripeSubscriptionUpdate(updatedSubscription);
                    }
                    break;

                case CqrsEventTypes.StripeSubDeleted:
                    var deletedSubscription = Stripe.Mapper <StripeSubscription> .MapFromJson(qi.Data);

                    if (deletedSubscription != null)
                    {
                        var paymentProviderService = Bootstrapper.GetKernel().Resolve <IPaymentProviderService>();

                        paymentProviderService.ProcessStripeSubscriptionCancellation(deletedSubscription);
                    }
                    break;

                case CqrsEventTypes.ClearDepartmentCache:

                    int departmentId;

                    if (int.TryParse(qi.Data, out departmentId))
                    {
                        var userProfileService = Bootstrapper.GetKernel().Resolve <IUserProfileService>();
                        //var departmentSettingsService = Bootstrapper.GetKernel().Resolve<IDepartmentSettingsService>();
                        var subscriptionService = Bootstrapper.GetKernel().Resolve <ISubscriptionsService>();
                        //var scheduledTasksService = Bootstrapper.GetKernel().Resolve<IScheduledTasksService>();
                        var departmentService   = Bootstrapper.GetKernel().Resolve <IDepartmentsService>();
                        var actionLogsService   = Bootstrapper.GetKernel().Resolve <IActionLogsService>();
                        var customStatesService = Bootstrapper.GetKernel().Resolve <ICustomStateService>();
                        var usersService        = Bootstrapper.GetKernel().Resolve <IUsersService>();

                        subscriptionService.ClearCacheForCurrentPayment(departmentId);
                        departmentService.InvalidateDepartmentUsersInCache(departmentId);
                        departmentService.InvalidateDepartmentInCache(departmentId);
                        departmentService.InvalidatePersonnelNamesInCache(departmentId);
                        userProfileService.ClearAllUserProfilesFromCache(departmentId);
                        usersService.ClearCacheForDepartment(departmentId);
                        actionLogsService.InvalidateActionLogs(departmentId);
                        customStatesService.InvalidateCustomStateInCache(departmentId);
                        departmentService.InvalidateDepartmentMembers();

                        userProfileService  = null;
                        subscriptionService = null;
                        departmentService   = null;
                        actionLogsService   = null;
                        customStatesService = null;
                        usersService        = null;
                    }
                    else
                    {
                    }
                    break;

                case CqrsEventTypes.NewChatMessage:
                    NewChatNotificationEvent newChatEvent = null;

                    if (qi != null && !String.IsNullOrWhiteSpace(qi.Data))
                    {
                        try
                        {
                            newChatEvent = ObjectSerialization.Deserialize <NewChatNotificationEvent>(qi.Data);
                        }
                        catch (Exception ex)
                        {
                        }

                        if (newChatEvent != null)
                        {
                            var userProfileService   = Bootstrapper.GetKernel().Resolve <IUserProfileService>();
                            var communicationService = Bootstrapper.GetKernel().Resolve <ICommunicationService>();
                            var usersService         = Bootstrapper.GetKernel().Resolve <IUsersService>();


                            if (newChatEvent != null && newChatEvent.RecipientUserIds != null && newChatEvent.RecipientUserIds.Count > 0)
                            {
                                List <UserProfile> profiles = new List <UserProfile>();
                                if (newChatEvent.RecipientUserIds.Count == 1)
                                {
                                    profiles.Add(userProfileService.GetProfileByUserId(newChatEvent.RecipientUserIds.First()));
                                }
                                else
                                {
                                    profiles.AddRange(userProfileService.GetSelectedUserProfiles(newChatEvent.RecipientUserIds));
                                }

                                var sendingUserProfile = userProfileService.GetProfileByUserId(newChatEvent.SendingUserId);

                                var chatResult = communicationService.SendChat(newChatEvent.Id, newChatEvent.SendingUserId, newChatEvent.GroupName, newChatEvent.Message, sendingUserProfile, profiles).Result;
                            }

                            userProfileService   = null;
                            communicationService = null;
                            usersService         = null;
                        }
                    }
                    break;

                case CqrsEventTypes.TroubleAlert:
                    TroubleAlertEvent troubleAlertEvent = null;
                    try
                    {
                        troubleAlertEvent = ObjectSerialization.Deserialize <TroubleAlertEvent>(qi.Data);
                    }
                    catch (Exception ex)
                    {
                    }

                    if (troubleAlertEvent != null && troubleAlertEvent.DepartmentId.HasValue)
                    {
                        var userProfileService        = Bootstrapper.GetKernel().Resolve <IUserProfileService>();
                        var communicationService      = Bootstrapper.GetKernel().Resolve <ICommunicationService>();
                        var usersService              = Bootstrapper.GetKernel().Resolve <IUsersService>();
                        var departmentService         = Bootstrapper.GetKernel().Resolve <IDepartmentsService>();
                        var unitsService              = Bootstrapper.GetKernel().Resolve <IUnitsService>();
                        var departmentGroupService    = Bootstrapper.GetKernel().Resolve <IDepartmentGroupsService>();
                        var callsService              = Bootstrapper.GetKernel().Resolve <ICallsService>();
                        var departmentSettingsService = Bootstrapper.GetKernel().Resolve <IDepartmentSettingsService>();
                        var geoLocationProvider       = Bootstrapper.GetKernel().Resolve <IGeoLocationProvider>();

                        var admins = departmentService.GetAllAdminsForDepartment(troubleAlertEvent.DepartmentId.Value);
                        var unit   = unitsService.GetUnitById(troubleAlertEvent.UnitId);
                        List <UserProfile> profiles = new List <UserProfile>();
                        Call   call             = null;
                        string departmentNumber = "";
                        string callAddress      = "No Call Address";
                        string unitAproxAddress = "Unknown Unit Address";

                        departmentNumber = departmentSettingsService.GetTextToCallNumberForDepartment(troubleAlertEvent.DepartmentId.Value);

                        if (admins != null)
                        {
                            profiles.AddRange(userProfileService.GetSelectedUserProfiles(admins.Select(x => x.Id).ToList()));
                        }

                        if (unit != null)
                        {
                            if (unit.StationGroupId.HasValue)
                            {
                                var groupAdmins = departmentGroupService.GetAllAdminsForGroup(unit.StationGroupId.Value);

                                if (groupAdmins != null)
                                {
                                    profiles.AddRange(userProfileService.GetSelectedUserProfiles(groupAdmins.Select(x => x.UserId).ToList()));
                                }
                            }

                            if (troubleAlertEvent.CallId.HasValue && troubleAlertEvent.CallId.GetValueOrDefault() > 0)
                            {
                                call = callsService.GetCallById(troubleAlertEvent.CallId.Value);

                                if (!String.IsNullOrEmpty(call.Address))
                                {
                                    callAddress = call.Address;
                                }
                                else if (!String.IsNullOrEmpty(call.GeoLocationData))
                                {
                                    string[] points = call.GeoLocationData.Split(char.Parse(","));

                                    if (points != null && points.Length == 2)
                                    {
                                        callAddress = geoLocationProvider.GetAproxAddressFromLatLong(double.Parse(points[0]), double.Parse(points[1]));
                                    }
                                }
                            }

                            if (!String.IsNullOrWhiteSpace(troubleAlertEvent.Latitude) && !String.IsNullOrWhiteSpace(troubleAlertEvent.Longitude))
                            {
                                unitAproxAddress = geoLocationProvider.GetAproxAddressFromLatLong(double.Parse(troubleAlertEvent.Latitude), double.Parse(troubleAlertEvent.Longitude));
                            }

                            communicationService.SendTroubleAlert(troubleAlertEvent, unit, call, departmentNumber, troubleAlertEvent.DepartmentId.Value, callAddress, unitAproxAddress, profiles);
                        }
                    }

                    break;

                case CqrsEventTypes.AuditLog:
                    AuditEvent auditEvent = null;
                    try
                    {
                        auditEvent = ObjectSerialization.Deserialize <AuditEvent>(qi.Data);
                    }
                    catch (Exception ex)
                    {
                    }

                    if (auditEvent != null)
                    {
                        var auditLogsRepository = Bootstrapper.GetKernel().Resolve <IGenericDataRepository <AuditLog> >();
                        var userProfileService  = Bootstrapper.GetKernel().Resolve <IUserProfileService>();

                        var profile = userProfileService.GetProfileByUserId(auditEvent.UserId);

                        var auditLog = new AuditLog();
                        auditLog.DepartmentId = auditEvent.DepartmentId;
                        auditLog.UserId       = auditEvent.UserId;
                        auditLog.LogType      = (int)auditEvent.Type;

                        switch (auditEvent.Type)
                        {
                        case AuditLogTypes.DepartmentSettingsChanged:
                            auditLog.Message = string.Format("{0} updated the department settings", profile.FullName.AsFirstNameLastName);
                            var compareLogic = new CompareLogic();
                            ComparisonResult auditCompareResult = compareLogic.Compare(auditEvent.Before, auditEvent.After);
                            auditLog.Data = auditCompareResult.DifferencesString;
                            break;

                        case AuditLogTypes.UserAdded:
                            if (auditEvent.After != null && auditEvent.After.GetType().BaseType == typeof(IdentityUser))
                            {
                                var newProfile = userProfileService.GetProfileByUserId(((IdentityUser)auditEvent.After).UserId);
                                auditLog.Message = string.Format("{0} added new user {1}", profile.FullName.AsFirstNameLastName, newProfile.FullName.AsFirstNameLastName);

                                auditLog.Data = $"New UserId: {newProfile.UserId}";
                            }
                            break;

                        case AuditLogTypes.UserRemoved:

                            if (auditEvent.Before != null && auditEvent.Before.GetType() == typeof(UserProfile))
                            {
                                auditLog.Message = $"{profile.FullName.AsFirstNameLastName} removed user {(((UserProfile)auditEvent.Before).FullName.AsFirstNameLastName)}";
                                auditLog.Data    = "No Data";
                            }

                            break;

                        case AuditLogTypes.GroupAdded:
                            if (auditEvent.After != null && auditEvent.After.GetType() == typeof(DepartmentGroup))
                            {
                                if (((DepartmentGroup)auditEvent.After).Type.HasValue && ((DepartmentGroup)auditEvent.After).Type.Value == (int)DepartmentGroupTypes.Station)
                                {
                                    auditLog.Message = $"{profile.FullName.AsFirstNameLastName} added station group {((DepartmentGroup)auditEvent.After).Name}";
                                }
                                else
                                {
                                    auditLog.Message = $"{profile.FullName.AsFirstNameLastName} added organizational group {((DepartmentGroup)auditEvent.After).Name}";
                                }

                                auditLog.Data = $"GroupId: {((DepartmentGroup)auditEvent.After).DepartmentGroupId}";
                            }
                            break;

                        case AuditLogTypes.GroupRemoved:
                            if (auditEvent.Before != null && auditEvent.Before.GetType() == typeof(DepartmentGroup))
                            {
                                auditLog.Message = string.Format("{0} removed group {1}", profile.FullName.AsFirstNameLastName, ((DepartmentGroup)auditEvent.Before).Name);
                                auditLog.Data    = "No Data";
                            }
                            break;

                        case AuditLogTypes.GroupChanged:
                            if (auditEvent.Before != null && auditEvent.Before.GetType() == typeof(DepartmentGroup) && auditEvent.After != null &&
                                auditEvent.After.GetType() == typeof(DepartmentGroup))
                            {
                                auditLog.Message = $"{profile.FullName.AsFirstNameLastName} updated group {((DepartmentGroup)auditEvent.After).Name}";
                                var compareLogicGroup = new CompareLogic();

                                ComparisonResult resultGroup = compareLogicGroup.Compare(auditEvent.Before, auditEvent.After);
                                auditLog.Data = resultGroup.DifferencesString;
                            }
                            break;

                        case AuditLogTypes.UnitAdded:
                            if (auditEvent.After != null && auditEvent.After.GetType() == typeof(Unit))
                            {
                                auditLog.Message = string.Format("{0} added unit {1}", profile.FullName.AsFirstNameLastName, ((Unit)auditEvent.After).Name);
                                auditLog.Data    = $"UnitId: {((Unit)auditEvent.After).UnitId}";
                            }
                            break;

                        case AuditLogTypes.UnitRemoved:
                            if (auditEvent.Before != null && auditEvent.Before.GetType() == typeof(Unit))
                            {
                                auditLog.Message = $"{profile.FullName.AsFirstNameLastName} removed unit {((Unit)auditEvent.Before).Name}";
                                auditLog.Data    = "No Data";
                            }
                            break;

                        case AuditLogTypes.UnitChanged:
                            if (auditEvent.Before != null && auditEvent.Before.GetType() == typeof(Unit) && auditEvent.After != null && auditEvent.After.GetType() == typeof(Unit))
                            {
                                auditLog.Message = $"{profile.FullName.AsFirstNameLastName} updated unit {((Unit)auditEvent.After).Name}";

                                var compareLogicUnit        = new CompareLogic();
                                ComparisonResult resultUnit = compareLogicUnit.Compare(auditEvent.Before, auditEvent.After);
                                auditLog.Data = resultUnit.DifferencesString;
                            }
                            break;

                        case AuditLogTypes.ProfileUpdated:
                            if (auditEvent.Before != null && auditEvent.Before.GetType() == typeof(UserProfile) && auditEvent.After != null && auditEvent.After.GetType() == typeof(UserProfile))
                            {
                                auditLog.Message = $"{profile.FullName.AsFirstNameLastName} updated the profile for {((UserProfile)auditEvent.After).FullName.AsFirstNameLastName}";

                                var compareLogicProfile        = new CompareLogic();
                                ComparisonResult resultProfile = compareLogicProfile.Compare(auditEvent.Before, auditEvent.After);
                                auditLog.Data = resultProfile.DifferencesString;
                            }
                            break;

                        case AuditLogTypes.PermissionsChanged:
                            if (auditEvent.Before != null && auditEvent.Before.GetType() == typeof(Permission) && auditEvent.After != null && auditEvent.After.GetType() == typeof(Permission))
                            {
                                auditLog.Message = $"{profile.FullName.AsFirstNameLastName} updated the department permissions";

                                var compareLogicProfile        = new CompareLogic();
                                ComparisonResult resultProfile = compareLogicProfile.Compare(auditEvent.Before, auditEvent.After);
                                auditLog.Data = resultProfile.DifferencesString;
                            }
                            break;
                        }

                        if (String.IsNullOrWhiteSpace(auditLog.Data))
                        {
                            auditLog.Data = "No Data";
                        }

                        if (!String.IsNullOrWhiteSpace(auditLog.Message))
                        {
                            auditLog.LoggedOn = DateTime.UtcNow;
                            auditLogsRepository.SaveOrUpdate(auditLog);
                        }
                    }
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            return(success);
        }
Exemplo n.º 12
0
        public async Task <DeviceRegistrationResult> RegisterUnitDevice([FromBody] DeviceRegistrationInput registrationInput)
        {
            if (this.ModelState.IsValid)
            {
                var result = new DeviceRegistrationResult();

                try
                {
                    if (registrationInput == null)
                    {
                        throw HttpStatusCode.BadRequest.AsException();
                    }

                    var push = new PushUri();
                    push.UserId       = UserId;
                    push.PlatformType = registrationInput.Plt;
                    push.PushLocation = registrationInput.Id;
                    push.DepartmentId = DepartmentId;

                    if (!String.IsNullOrWhiteSpace(registrationInput.Uri))
                    {
                        push.PushLocation = HttpUtility.UrlDecode(registrationInput.Uri);
                    }

                    push.DeviceId = registrationInput.Did;

                    if (registrationInput.Uid != 0)
                    {
                        push.UnitId = registrationInput.Uid;
                    }

                    try
                    {
                        push = _pushUriService.SavePushUri(push);
                    }
                    catch { }

                    PushRegisterionEvent pushRegisterionEvent = new PushRegisterionEvent();
                    pushRegisterionEvent.PushUriId    = push.PushUriId;
                    pushRegisterionEvent.UserId       = UserId;
                    pushRegisterionEvent.PlatformType = registrationInput.Plt;
                    pushRegisterionEvent.PushLocation = registrationInput.Id;
                    pushRegisterionEvent.DepartmentId = DepartmentId;
                    pushRegisterionEvent.DeviceId     = registrationInput.Did;
                    pushRegisterionEvent.Uuid         = registrationInput.Id;

                    if (registrationInput.Uid != 0)
                    {
                        pushRegisterionEvent.UnitId = registrationInput.Uid;
                    }

                    CqrsEvent registerUnitPushEvent = new CqrsEvent();
                    registerUnitPushEvent.Type = (int)CqrsEventTypes.UnitPushRegistration;
                    registerUnitPushEvent.Data = ObjectSerialization.Serialize(pushRegisterionEvent);

                    await _cqrsProvider.EnqueueCqrsEventAsync(registerUnitPushEvent);

                    //await _pushService.RegisterUnit(push);

                    result.Sfl = true;
                    result.Id  = push.PushUriId;

                    return(result);
                }
                catch (Exception ex)
                {
                    result.Sfl = false;
                    Framework.Logging.LogException(ex);

                    return(result);
                }
            }

            throw HttpStatusCode.BadRequest.AsException();
        }
Exemplo n.º 13
0
 public void UnRegisterNotificationOnly(PushUri pushUri)
 {
     _notificationProvider.UnRegisterPushByUserDeviceId(pushUri);
 }
Exemplo n.º 14
0
        public async Task <bool> UnRegisterUnit(PushUri pushUri)
        {
            await _unitNotificationProvider.UnRegisterPushByUserDeviceId(pushUri);

            return(true);
        }