public void SaveLocationLog(LocationLog LocationLog) { if (LocationLog.Id == 0) { context.LocationLogs.Add(LocationLog); } else { var editMe = context.LocationLogs.Find(LocationLog.Id); if (editMe != null) { // dbEntry.Name = LocationLog.Name; // dbEntry.Message = LocationLog.Message; // dbEntry.TimeStamp = LocationLog.TimeStamp; } } try { context.SaveChanges(); } catch (OptimisticConcurrencyException) { //context.(RefreshMode.ClientWins, dbModels.Models.LocationLog); //context.SaveChanges(); } // context.SaveChanges(); }
public APIResponse Put(int id, [FromBody] LocationLog model) { APIResponse response = new APIResponse(); if (model == null || model.ID != id) { response.Error = 1; return(response); } var item = _context.LocationLog.FirstOrDefault(m => m.ID == id); if (item == null) { response.Error = 2; return(response); } item.TerminalID = model.TerminalID; item.GDLocation = model.GDLocation; item.BDLocation = model.BDLocation; item.Latitude = model.Latitude; item.Longitude = model.Longitude; item.StationID = model.StationID; _context.LocationLog.Update(item); _context.SaveChanges(); return(response); }
public async Task <ActionResult <LocationLog_LocationLogDTO> > Update([FromBody] LocationLog_LocationLogDTO LocationLog_LocationLogDTO) { if (!ModelState.IsValid) { throw new BindException(ModelState); } if (!await HasPermission(LocationLog_LocationLogDTO.Id)) { return(Forbid()); } LocationLog LocationLog = ConvertDTOToEntity(LocationLog_LocationLogDTO); LocationLog = await LocationLogService.Update(LocationLog); LocationLog_LocationLogDTO = new LocationLog_LocationLogDTO(LocationLog); if (LocationLog.IsValidated) { return(LocationLog_LocationLogDTO); } else { return(BadRequest(LocationLog_LocationLogDTO)); } }
private static async Task <IActionResult> ExecuteLaunchRequestAsync(CEKRequest request, CloudTable locationLogs, AppConfiguration config) { var response = new CEKResponse(); var taskForSettings = MessagingChatSettings.GetSettingsByUserIdAsync(locationLogs, request.Session.User.UserId); var taskForLocationLog = LocationLog.GetLocationLogByUserIdAsync(locationLogs, request.Session.User.UserId); await Task.WhenAll(taskForSettings, taskForLocationLog); var settings = taskForSettings.Result ?? new MessagingChatSettings { RowKey = request.Session.User.UserId }; var locationLog = taskForLocationLog.Result; try { if (!settings.IsLineFrend) { response.AddText(ClovaMessages.GetAddingLineFrendMessage()); return(new OkObjectResult(response)); } AddHistory(settings); response.AddText(ClovaMessages.GetGuideMessage(settings.YourName)); if (locationLog == null || !DateTimeOffsetUtils.IsToday(locationLog.Timestamp)) { // データが無い response.AddText(ClovaMessages.GetNoLogMessage(settings.YourName)); await AskCurrentLocationAsync(request, config, settings); return(new OkObjectResult(response)); } if (DateTimeOffsetUtils.IsBefore(locationLog.Timestamp, TimeSpan.Parse(config.Cek.IsBeforeThreshold ?? Clova.IsBeforeThresholdDefaultValue))) { // 古いデータ response.AddText(ClovaMessages.GetOldLocationMessage(settings.YourName, locationLog)); await AskCurrentLocationAsync(request, config, settings); return(new OkObjectResult(response)); } // データがある response.AddText(ClovaMessages.GetLocationMessage(settings.YourName, locationLog)); if (!string.IsNullOrEmpty(locationLog.Comment)) { response.AddText(ClovaMessages.GetCommentMessage(settings.YourName, locationLog)); } else if (!string.IsNullOrEmpty(locationLog.AudioCommentUrl)) { response.AddText(ClovaMessages.GetVoiceMessagePrefixMessage(settings.YourName)); response.AddUrl(locationLog.AudioCommentUrl); } return(new OkObjectResult(response)); } finally { await locationLogs.ExecuteAsync(TableOperation.InsertOrReplace(settings)); } }
public override void OnLocationAvailability(LocationAvailability locationAvailability) { if (locationAvailability != null) { bool flag = locationAvailability.IsLocationAvailable; LocationLog.Info(TAG, "onLocationAvailability isLocationAvailable:" + flag); } }
public async Task <bool> ValidateUser(LocationLog LocationLog) { if (LocationLog.AppUserId != CurrentContext.UserId) { LocationLog.AddError(nameof(LocationLogValidator), nameof(LocationLog.Id), ErrorCode.NotCurrentUser); } return(LocationLog.AppUserId == CurrentContext.UserId); }
public async Task <bool> Delete(LocationLog LocationLog) { await DataContext.LocationLog.Where(x => x.Id == LocationLog.Id).UpdateFromQueryAsync(x => new LocationLogDAO { DeletedAt = StaticParams.DateTimeNow, UpdatedAt = StaticParams.DateTimeNow }); return(true); }
public static string GetCommentMessage(string name, LocationLog locationLog) { if (string.IsNullOrEmpty(locationLog.Comment)) { return(""); } return($"また、{name}から、メッセージをもらっています。 {locationLog.Comment}"); }
public async Task <LocationLog> Get(long Id) { LocationLog LocationLog = await UOW.LocationLogRepository.Get(Id); if (LocationLog == null) { return(null); } return(LocationLog); }
public static void AddLocationLog(string dbLocationName, string message, int concealmentLevel) { ILocationLogRepository LocationLogRepo = new EFLocationLogRepository(); var newlog = new LocationLog(); newlog.dbLocationName = dbLocationName; newlog.Message = message; newlog.Timestamp = DateTime.UtcNow; newlog.ConcealmentLevel = concealmentLevel; LocationLogRepo.SaveLocationLog(newlog); }
public async Task <int> OnLocationView(LocationResult location) { var logItem = new LocationLog { Title = location.Title, WoeId = location.WoeId, Viewed = DateTime.Now }; _db.Add(logItem); return(await _db.SaveChangesAsync()); }
public AppUser_LocationLogDTO(LocationLog LocationLog) { this.Id = LocationLog.Id; this.PreviousId = LocationLog.PreviousId; this.AppUserId = LocationLog.AppUserId; this.Latitude = LocationLog.Latitude; this.Longtitude = LocationLog.Longtitude; this.UpdateInterval = LocationLog.UpdateInterval; this.Previous = LocationLog.Previous == null ? null : new AppUser_LocationLogDTO(LocationLog.Previous); this.Errors = LocationLog.Errors; }
public Log(string fileName, LocationLog locationLog = LocationLog.LogFolder, TimeStampType timestampType = TimeStampType.JustTime, FileNameSuffixLog suffixLog = FileNameSuffixLog.Date, int maxLogs = 10) { TimeStampType = timestampType; LocationLog = locationLog; FileNameSuffix = suffixLog; _maxLogs = maxLogs; if (!string.IsNullOrEmpty(Path.GetDirectoryName(fileName))) { LocationLog = LocationLog.Custom; _folder = Path.GetDirectoryName(fileName); _filename = Path.GetFileNameWithoutExtension(fileName); } else { _filename = Path.GetFileNameWithoutExtension(fileName); switch (locationLog) { case LocationLog.Custom: case LocationLog.SameFolder: _folder = "."; break; case LocationLog.LogFolder: _folder = "./log"; break; case LocationLog.ProgramDataFolder: _folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), _vendor, _system); break; } _folder = Path.GetFullPath(_folder); } LastException = ""; if (!Directory.Exists(_folder)) { try { Directory.CreateDirectory(_folder); } catch (Exception e) { LastException = e.Message; throw new LogException("Erro ao criar diretório " + _folder, e); } if (!Directory.Exists(_folder)) { throw new LogException("Diretório " + _folder + " não foi encontrado"); } } }
private void RemoveLocationUpdatesWithCallback() { try { Task voidTask = mFusedLocationProviderClient.RemoveLocationUpdates(mLocationCallback); voidTask .AddOnSuccessListener(new RemoveLocCallUpdateOnSuccessListener()) .AddOnFailureListener(new RemoveLocCallUpdateOnFailureListener()); } catch (Exception e) { LocationLog.Error(TAG, "removeLocatonUpdatesWithCallback exception:" + e.Message); } }
/// <summary> /// Registers the location. /// </summary> /// <param name="logItem">The log item.</param> /// <returns>LocationLog.</returns> public LocationLog RegisterLocation(LocationLog logItem) { try { var poi = GetPointOfInterest(logItem.PoIId); return(Provider <LocationLog> .Save(logItem)); } catch (Exception exception) { logItem.AddError(exception.Message); _logger.Error(exception.GetCombinedMessages()); return(logItem); } }
public LocationLog_LocationLogDTO(LocationLog LocationLog) { this.Id = LocationLog.Id; this.PreviousId = LocationLog.PreviousId; this.AppUserId = LocationLog.AppUserId; this.Latitude = LocationLog.Latitude; this.Longtitude = LocationLog.Longtitude; this.UpdateInterval = LocationLog.UpdateInterval; this.AppUser = LocationLog.AppUser == null ? null : new LocationLog_AppUserDTO(LocationLog.AppUser); this.Previous = LocationLog.Previous == null ? null : new LocationLog_LocationLogDTO(LocationLog.Previous); this.CreatedAt = LocationLog.CreatedAt; this.UpdatedAt = LocationLog.UpdatedAt; this.Errors = LocationLog.Errors; }
private async Task InputCommentAsync(ContextState contextState, MessageEvent ev) { if (ev.Message.Type == EventMessageType.Text) { var locationLog = await LocationLog.GetLocationLogByUserIdAsync(contextState.StateStoreTable, ev.Source.UserId); if (locationLog == null) { await ReplyUnknownMessageAsync(contextState, ev); return; } locationLog.Comment = ((TextEventMessage)ev.Message).Text; await LocationLog.InsertOrReplaceAsync(contextState.StateStoreTable, locationLog); await FinishInputAsync(contextState, ev, locationLog); SetNextCallMethod(nameof(InitializeAsync)); } else if (ev.Message.Type == EventMessageType.Audio) { var locationLog = await LocationLog.GetLocationLogByUserIdAsync(contextState.StateStoreTable, ev.Source.UserId); if (locationLog == null) { await ReplyUnknownMessageAsync(contextState, ev); return; } using (var audio = await contextState.Client.GetContentStreamAsync(ev.Message.Id)) { var blob = await contextState.Binder.BindAsync <CloudBlockBlob>(new BlobAttribute($"files/{ev.Source.UserId}/{ev.Message.Id}{GetFileExtension(audio.ContentHeaders.ContentType.MediaType)}", FileAccess.Write)); await blob.UploadFromStreamAsync(audio); locationLog.AudioCommentUrl = blob.Uri.ToString(); } await LocationLog.InsertOrReplaceAsync(contextState.StateStoreTable, locationLog); await FinishInputAsync(contextState, ev, locationLog); SetNextCallMethod(nameof(InitializeAsync)); } else { await ReplyUnknownMessageAsync(contextState, ev); } }
public override void Execute(IDataContext context) { ContextQuery = ctx => { var player = ctx.AsQueryable <Player>() .Include(p => p.User) .Include(i => i.PlayerLogs) .SingleOrDefault(p => p.User.Id == UserId); if (player == null) { throw new DomainException($"Player with user ID '{UserId}' could not be found"); } if (player.Mobility != PvPStatics.MobilityFull) { throw new DomainException("You must be animate in order to shout!"); } if (player.ShoutsRemaining <= 0) { throw new DomainException("You can only shout once per turn."); } var hushed = ctx.AsQueryable <Effect>() .Where(e => e.EffectSource.Id == CharacterPrankProcedures.HUSHED_EFFECT && e.Owner.Id == player.Id && e.Duration > 0) .Any(); if (hushed) { throw new DomainException("You have been hushed and cannot currently shout."); } Message = Message.Replace("<", "<").Replace(">", ">"); // remove suspicious characters var log = LocationLog.Create(player.Location, $"<span class='playerShoutNotification'>{player.GetFullName()} shouted <b>\"{Message}\"</b> here.</span>"); player.Shout(Message); ctx.Update(player); ctx.Add(log); ctx.Commit(); }; ExecuteInternal(context); }
/// <summary> /// Registers the location. /// </summary> /// <param name="logItem">The log item.</param> /// <returns>LocationLog.</returns> public LocationLog RegisterLocation(LocationLog logItem) { var clt = CreateClient(); try { return(clt .RegisterLocation(logItem.Zip()) .Unzip <LocationLog>()); } finally { CloseClient(clt); } }
public APIResponse Post([FromBody] LocationLog model) { APIResponse response = new APIResponse(); if (model == null) { response.Error = 1; return(response); } //model.SamplingTime = (long)(DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0)).TotalMilliseconds; _context.LocationLog.Add(model); _context.SaveChanges(); return(response); }
private async Task FinishInputAsync(ContextState contextState, MessageEvent ev, LocationLog locationLog = null) { locationLog = locationLog ?? await LocationLog.GetLocationLogByUserIdAsync(contextState.StateStoreTable, ev.Source.UserId); if (locationLog == null) { await ReplyUnknownMessageAsync(contextState, ev); return; } await contextState.Client.ReplyMessageAsync(ev.ReplyToken, LineMessages.GetFinishInputMessage(contextState.Settings, locationLog)); SetNextCallMethod(nameof(InitializeAsync)); }
public async Task <ActionResult <LocationLog_LocationLogDTO> > Get([FromBody] LocationLog_LocationLogDTO LocationLog_LocationLogDTO) { if (!ModelState.IsValid) { throw new BindException(ModelState); } if (!await HasPermission(LocationLog_LocationLogDTO.Id)) { return(Forbid()); } LocationLog LocationLog = await LocationLogService.Get(LocationLog_LocationLogDTO.Id); return(new LocationLog_LocationLogDTO(LocationLog)); }
public override void OnLocationResult(LocationResult locationResult) { if (locationResult != null) { IList <Android.Locations.Location> locations = locationResult.Locations; if (locations.Count != 0) { foreach (Android.Locations.Location location in locations) { LocationLog.Info(TAG, "onLocationResult location[Longitude,Latitude,Accuracy]:" + location.Longitude + "," + location.Latitude + "," + location.Accuracy); } } } }
private async Task ExecuteLocationMessageAsync(ContextState contextState, MessageEvent messageEvent) { var locationMessage = (LocationEventMessage)messageEvent.Message; var locationLog = new LocationLog { RowKey = messageEvent.Source.UserId, Latitude = locationMessage.Latitude, Longitude = locationMessage.Longitude, Name = locationMessage.Title, Address = locationMessage.Address, }; await contextState.StateStoreTable.ExecuteAsync(TableOperation.InsertOrReplace(locationLog)); await contextState.Client.ReplyMessageAsync(messageEvent.ReplyToken, LineMessages.GetConfirmMessage(LineMessages.AskCommentMessage)); SetNextCallMethod(nameof(AskingInputCommentAsync)); }
private void RequestLocationUpdatesWithCallback() { try { LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder(); builder.AddLocationRequest(mLocationRequest); LocationSettingsRequest locationSettingsRequest = builder.Build(); // Before requesting location update, invoke checkLocationSettings to check device settings. Task locationSettingsResponseTask = mSettingsClient.CheckLocationSettings(locationSettingsRequest); locationSettingsResponseTask .AddOnSuccessListener(new LocCallSettOnSuccessListenerImpl(mFusedLocationProviderClient, mLocationRequest, mLocationCallback)) .AddOnFailureListener(new LocCallSettOnFailureListenerImpl(this)); } catch (Exception e) { LocationLog.Error(TAG, "requestLocationUpdatesWithCallback exception:" + e.Message); } }
public void Try_RegisterLocationLog() { try { LocationLog log = new LocationLog() {PoIId = "My bedroom", Accuracy = (float)0.0, Bearing = (float)123.01532, Latitude = 56.25153, Longitude = 6.235, Altitude = 51.212, Speed = (float)2.3}; //log = LatiProvider // .Latis // .RegisterLocation(log); log = LatiPortal .Latis .RegisterLocation(log); Console.WriteLine("Log: {0} - Lon:{1}", log.PoIId, log.Longitude); } catch (Exception exception) { Assert.Fail(exception.Message); } }
public async Task <LocationLog> Get(long Id) { LocationLog LocationLog = await DataContext.LocationLog.AsNoTracking() .Where(x => x.Id == Id) .Where(x => x.DeletedAt == null) .Select(x => new LocationLog() { CreatedAt = x.CreatedAt, UpdatedAt = x.UpdatedAt, Id = x.Id, PreviousId = x.PreviousId, AppUserId = x.AppUserId, Latitude = x.Latitude, Longtitude = x.Longtitude, UpdateInterval = x.UpdateInterval, AppUser = x.AppUser == null ? null : new AppUser { Id = x.AppUser.Id, Username = x.AppUser.Username, Password = x.AppUser.Password, DisplayName = x.AppUser.DisplayName, Email = x.AppUser.Email, Phone = x.AppUser.Phone, }, Previous = x.Previous == null ? null : new LocationLog { Id = x.Previous.Id, PreviousId = x.Previous.PreviousId, AppUserId = x.Previous.AppUserId, Latitude = x.Previous.Latitude, Longtitude = x.Previous.Longtitude, UpdateInterval = x.Previous.UpdateInterval, }, }).FirstOrDefaultAsync(); if (LocationLog == null) { return(null); } return(LocationLog); }
public async Task <bool> ValidateId(LocationLog LocationLog) { LocationLogFilter LocationLogFilter = new LocationLogFilter { Skip = 0, Take = 10, Id = new IdFilter { Equal = LocationLog.Id }, Selects = LocationLogSelect.Id }; int count = await UOW.LocationLogRepository.Count(LocationLogFilter); if (count == 0) { LocationLog.AddError(nameof(LocationLogValidator), nameof(LocationLog.Id), ErrorCode.IdNotExisted); } return(count == 1); }
public async Task <bool> Update(LocationLog LocationLog) { LocationLogDAO LocationLogDAO = DataContext.LocationLog.Where(x => x.Id == LocationLog.Id).FirstOrDefault(); if (LocationLogDAO == null) { return(false); } LocationLogDAO.Id = LocationLog.Id; LocationLogDAO.PreviousId = LocationLog.PreviousId; LocationLogDAO.AppUserId = LocationLog.AppUserId; LocationLogDAO.Latitude = LocationLog.Latitude; LocationLogDAO.Longtitude = LocationLog.Longtitude; LocationLogDAO.UpdateInterval = LocationLog.UpdateInterval; LocationLogDAO.UpdatedAt = StaticParams.DateTimeNow; await DataContext.SaveChangesAsync(); await SaveReference(LocationLog); return(true); }
public static void RequestActivityPermission(Context context) { if (Build.VERSION.SdkInt <= BuildVersionCodes.P) { if (ActivityCompat.CheckSelfPermission(context, "com.huawei.hms.permission.ACTIVITY_RECOGNITION") == Permission.Denied) { string[] permissions = { "com.huawei.hms.permission.ACTIVITY_RECOGNITION" }; ActivityCompat.RequestPermissions((Activity)context, permissions, 1); LocationLog.Info(TAG, "requestActivityTransitionButtonHandler: apply permission"); } } else { if (ActivityCompat.CheckSelfPermission(context, "android.permission.ACTIVITY_RECOGNITION") == Permission.Denied) { string[] permissions = { "android.permission.ACTIVITY_RECOGNITION" }; ActivityCompat.RequestPermissions((Activity)context, permissions, 2); LocationLog.Info(TAG, "requestActivityTransitionButtonHandler: apply permission"); } } }
public void OnFailure(Java.Lang.Exception e) { LocationLog.Error(TAG, "checkLocationSetting onFailure:" + e.Message); int statusCode = ((ApiException)e).StatusCode; switch (statusCode) { case LocationSettingsStatusCodes.ResolutionRequired: try { //When the startResolutionForResult is invoked, a dialog box is displayed, asking you to open the corresponding permission. ResolvableApiException rae = (ResolvableApiException)e; rae.StartResolutionForResult(callbackActivity, 0); } catch (IntentSender.SendIntentException sie) { LocationLog.Error(TAG, "PendingIntent unable to execute request."); } break; } }