protected override IEnumerable <Control> InitializeControls(string oldValue)
{
var controls = base.InitializeControls(oldValue);
_control.DisplayMemberPath = "Name";
_control.SelectedValuePath = "Id";
_control.DropDownOpened += async(sender, args) =>
{
if (Field.List.ContentTypes == null || Field.List.Web.ContentTypes == null)
{
StatusNotification.NotifyWithProgress("Loading Content Types");
await Field.List.Web.Client.FillContentTypes(Field.List);
StatusNotification.Notify("Content Types loaded");
}
var contentTypes = Field.List.ContentTypes
.OrderBy(ct => ct.Name)
.Concat(Field.List.Web.ContentTypes.OrderBy(ct => ct.Name));
_control.ItemsSource =
contentTypes.Select(ct => new
{
ct.Id,
Name = Field.List.ContentTypes.Contains(ct) ? "List." + ct.Name : ct.Name
});
};
return(controls);
}
private async void ucConnectButton_Click(object sender, RoutedEventArgs e)
{
Telemetry.Instance.Native?.TrackEvent("Connect.OK", new Dictionary <string, string>
{
{ "ProviderType", Model.ProviderType.ToString() },
});
var client = SharePointProviderFactory.Create(Model.ProviderType);
try
{
Model.IsConnecting = true;
StatusNotification.NotifyWithProgress("Connecting...");
if (await client.Connect(Model.SharePointWebUrl, Model.UserName, Model.UserPassword) != null)
{
Client = client;
Model.AddNewUrl(Model.SharePointWebUrl);
Model.AddUserToHistory(Model.UserName);
Model.Save();
OnDialogResult(client);
}
StatusNotification.Notify("Connected");
}
catch (Exception ex)
{
Model.ErrorMessage = "Error: " + ExceptionHandler.HandleConnection(ex);
}
Model.IsConnecting = false;
}
public IHttpActionResult PutStatusNotification(int id, StatusNotification statusNotification)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != statusNotification.StatusNotificationId)
{
return(BadRequest());
}
db.Entry(statusNotification).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!StatusNotificationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private async Task <string> TradeInfo(StatusNotification sn)
{
SearchOrders so = new SearchOrders
{
MerchantID = sn.MerchantID,
AllPayLogisticsID = sn.AllPayLogisticsID,
TimeStamp = (Int32)DateTimeOffset.Now.ToUnixTimeSeconds(),
HashKey = Merchant.HashKey,
HashIV = Merchant.HashIV,
PlatformID = string.Empty
};
_searchOrder.EnableSecurityProtocol = true;
var request = await _searchOrder.PostAsyncForECPay(Links.TradeInfo, so);
if (request.Success)
{
if (request.Response.Substring(0, 1) != "0")
{
var json = ObjectConvert <TradeInfoResponse> .QueryStringToJson(request.Response);
return(json.HandlingCharge.ToString());
}
else
{
return(request.Response);
}
}
else
{
return(request.Message);
}
}
/// <summary>
/// Method to get pulse of User during exercise
/// </summary>
/// <param name="user">User whose pulse you want to get </param>
/// <returns></returns>
public int GetPulsePerMinute(User user, Exercises exercise)
{
var randomPulse = new Random();
StatusNotification?.Invoke("Pulse statistic ready!");
return(randomPulse.Next(60, 120));
}
public async Task AddQuery(SList list)
{
if (list == null)
{
return;
}
if (list.Fields?.Count == 0)
{
try
{
StatusNotification.NotifyWithProgress("Prepairing list: " + list.Title);
await list.Web.Client.FillListFields(list);
StatusNotification.Notify("List ready");
}
catch (Exception)
{
StatusNotification.Notify("Prepairing list failed");
return;
}
}
this.SelectedIndex = this.Items.Add(
new ClosableTabItem
{
HeaderText = list.Title,
Content = new QueryTab(list)
{
Margin = new Thickness(4)
}
});
CommandManager.InvalidateRequerySuggested();
}
private void ShowNotificationMessage(string message, int duration)
{
var textSize = FontUtility.GetTextSize(StatusNotification.FontFamily, StatusNotification.FontSize, message);
StatusNotification.Width = textSize.Width + 100; // actual width + padding
StatusNotification.Height = textSize.Height + 50; // actual height + padding
StatusNotification.Show(message, duration);
}
/// <summary>
/// Method to add exercises to user tracker
/// </summary>
/// <param name="user">User to which you want to add exercise</param>
/// <param name="exercise">Exercise you want to add</param>
/// <param name="exerciseStart">Date when you have done exercise</param>
/// <param name="exerciseEnd">Date when you have finished exercise</param>
/// <param name="units">Specific unit of exercise (distance\times etc.)</param>
public void AddNewExercise(User user, Exercises exercise, DateTime exerciseStart, DateTime exerciseEnd, double units)
{
var statisticService = new StatisticService();
statisticService.StatusNotification += NotificationManager.SendStatusNotification;
statisticService.ErrorNotification += NotificationManager.SendErrorNotification;
switch (exercise)
{
case Exercises.PushUps:
var newPushUps = new PushUpSeries
{
Name = $"PushUps #{user.PushUps.Count + 1}",
ExerciseStart = exerciseStart,
ExerciseEnd = exerciseEnd,
ExerciseTimeSpan = exerciseEnd - exerciseStart,
Count = (int)units,
};
user.PushUps.Add(newPushUps);
StatusNotification?.Invoke($"Push Ups #{user.PushUps.Count} for user {user.Name} successfully added!");
user.AvaragePushUps = statisticService.GetAverageStatistic(user, exercise);
break;
case Exercises.Run:
var newRun = new Run
{
Name = $"Run #{user.Runs.Count + 1}",
ExerciseStart = exerciseStart,
ExerciseEnd = exerciseEnd,
ExerciseTimeSpan = exerciseEnd - exerciseStart,
Distance = units,
};
user.Runs.Add(newRun);
StatusNotification?.Invoke($"Run #{user.Runs.Count} for user {user.Name} successfully added!");
user.AvarageRunDistance = statisticService.GetAverageStatistic(user, exercise);
break;
case Exercises.Squats:
var newSquats = new SquatSeries
{
Name = $"Squats #{user.Squats.Count + 1}",
ExerciseStart = exerciseStart,
ExerciseEnd = exerciseEnd,
ExerciseTimeSpan = exerciseEnd - exerciseStart,
Count = (int)units,
};
user.Squats.Add(newSquats);
StatusNotification?.Invoke($"Squats #{user.Squats.Count} for user {user.Name} successfully added!");
user.AvarageSquats = statisticService.GetAverageStatistic(user, exercise);
break;
default:
ErrorNotification?.Invoke("No such Exercise!");
break;
}
user.AvarageExercisePulse = statisticService.GetPulsePerMinute(user, exercise);
}
/// <summary>
/// 엘리베이터 감시반에서 통합 서버로 보내는 정보 프로토콜 수신
/// </summary>
/// <param name="sender"></param>
/// <param name="Data"></param>
/// <returns></returns>
private bool StatusNotificationCatch(object sender, byte[] Data)
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} [Controller : StatusNotificationCatch] {System.Text.Encoding.ASCII.GetString(Data)} Status Received.");
StatusNotification statusNoti = new StatusNotification();
var returnResult = this.unitDataController.ReceiveStatus(statusNoti.SetByte(Data));
return(true);
}
/// <summary>
/// Parses a xml into a StatusNotification object.
/// </summary>
/// <param name="notificationXml"></param>
/// <returns></returns>
public StatusNotification ParseNotification(string notificationXml)
{
// Gets a xml serializer.
ISerializer serializer = SerializerFactory.Create("xml");
// Parses the xml into a StatusNotification object.
StatusNotification statusNotification = serializer.DeserializeObject <StatusNotification>(notificationXml);
return(statusNotification);
}
private void ReportConnectionTestStarted()
{
DispatchOnUiThread(() =>
{
var notification = new StatusNotification("PleaseWait", "Testing", NotificationType.Progress);
Notifications.ShowNotifications(new List <INotification> {
notification
});
});
}
public IHttpActionResult GetStatusNotification(int id)
{
StatusNotification statusNotification = _repo.GetStatusNotification(id);
if (statusNotification == null)
{
return(NotFound());
}
return(Ok(statusNotification));
}
internal static DataNotificationRequest DataNotificationRequest(string transactionId)
{
var notifier = new Notifier(Type.HIP, "10000005");
const string consentId = "ConsentId";
var statusNotification = new StatusNotification(
SessionStatus.TRANSFERRED,
"10000005",
new List <StatusResponse>());
return(new DataNotificationRequest(transactionId, DateTime.Now, notifier, statusNotification, consentId, Guid.NewGuid()));
}
private void ShowNotificationMessage(string message, int duration)
{
if (StatusNotification == null)
{
this.FindName("StatusNotification"); // Lazy loading
}
var textSize = FontUtility.GetTextSize(StatusNotification.FontFamily, StatusNotification.FontSize, message);
StatusNotification.Width = textSize.Width + 100; // actual width + padding
StatusNotification.Height = textSize.Height + 50; // actual height + padding
StatusNotification.Show(message, duration);
}
private void ReportSuccess()
{
DispatchOnUiThread(() =>
{
var notification = new StatusNotification("ConnectionTestCaption", "ConnectionTestSuccessful", NotificationType.Success);
Notifications.ShowNotifications(new List <INotification> {
notification
});
});
LastTestDidSucceed = true;
}
public IHttpActionResult DeleteStatusNotification(int id)
{
StatusNotification statusNotification = db.StatusNotifications.Find(id);
if (statusNotification == null)
{
return(NotFound());
}
db.StatusNotifications.Remove(statusNotification);
db.SaveChanges();
return(Ok(statusNotification));
}
private void UtilityIndicator_OnTapped(object sender, TappedRoutedEventArgs e)
{
if (sender == PathIndicator && !string.IsNullOrEmpty(PathIndicator.Text))
{
FocusOnSelectedTextEditor();
var pathData = new DataPackage();
pathData.SetText(PathIndicator.Text);
Windows.ApplicationModel.DataTransfer.Clipboard.SetContent(pathData);
StatusNotification.Show("Copied", 1500);
}
else if (sender is TextBlock textBlock)
{
textBlock.ContextFlyout?.ShowAt(textBlock);
}
}
public DataNotificationRequest(
string transactionId,
DateTime doneAt,
Notifier notifier,
StatusNotification statusNotification,
string consentId,
Guid requestId)
{
TransactionId = transactionId;
DoneAt = doneAt;
Notifier = notifier;
StatusNotification = statusNotification;
ConsentId = consentId;
RequestId = requestId;
}
public IHttpActionResult PostStatusNotification([FromBody] StatusNotification statusNotification)
{
// we want to associate this notification with a server
var server = _repo.GetServer(statusNotification.Server.Name);
statusNotification.ServerId = server.ServerId;
statusNotification.Server = null;
if (_repo.AddStatusNotification(statusNotification) && _repo.Save())
{
return(CreatedAtRoute("DefaultApi", new { id = statusNotification.StatusNotificationId }, statusNotification));
}
// we are going to let them know that the Add didn't work
return(BadRequest(ModelState));
}
/// <summary>
/// Web App으로 전송하는 메소드
/// </summary>
/// <param name="status"></param>
/// <param name="date"></param>
private void SendStatusData(StatusNotification status, DateTime date)
{
var dataType = "";
if (Encoding.UTF8.GetString(status.Alarm) == "00")
{
dataType = "general";
Task <bool> task = Task.Run <bool>(async() => await httpClientTransfer.PostWebAPI(this.azureWebAppURL, status, this.buildingID, this.deviceID, date, dataType));
}
else //긴급
{
dataType = "emergency";
Task <bool> emergencyTask = Task.Run <bool>(async() => await httpClientTransfer.PostWebAPI(this.azureWebAppURL, status, this.buildingID, this.deviceID, date, dataType));
dataType = "general";
Task <bool> generalTask = Task.Run <bool>(async() => await httpClientTransfer.PostWebAPI(this.azureWebAppURL, status, this.buildingID, this.deviceID, date, dataType));
}
}
private async void SaveChangesCommand_Executed(object sender, ExecutedRoutedEventArgs e)
{
Telemetry.Instance.Native?.TrackEvent("Main.SaveChanges");
var dirtyItems = ucQueries.SelectedQueryTab.ucItems.GetDirtyItems();
var index = 0;
try
{
foreach (var listItem in dirtyItems)
{
StatusNotification.Notify("Updating item with id: " + listItem.Id, ++index, dirtyItems.Count);
try
{
await listItem.Update();
}
catch
{
listItem.CancelChanges();
if (dirtyItems.Last() == listItem)
{
MessageBox.Show("Couldn't update item with id: " + listItem.Id, "SmartCAML",
MessageBoxButton.OK, MessageBoxImage.Information);
}
else if (
MessageBox.Show(
"Couldn't update item with id: " + listItem.Id + "\n\n Would you like to continue?",
"SmartCAML",
MessageBoxButton.OKCancel, MessageBoxImage.Question) != MessageBoxResult.OK)
{
break;
}
}
}
StatusNotification.Notify("Update completed");
}
catch (Exception ex)
{
StatusNotification.Notify("Update failed");
ExceptionHandler.Handle(ex, "The request failed.");
}
}
/// <summary>
/// Azure에 구축된 Web App으로 데이터를 전송하는 함수
/// </summary>
/// <param name="webappURL"></param>
/// <param name="recevieData"></param>
/// <param name="buildingID"></param>
/// <param name="deviceID"></param>
/// <param name="dates"></param>
/// <param name="type"></param>
/// <returns></returns>
public async Task <bool> PostWebAPI(string webappURL, StatusNotification recevieData, string buildingID, string deviceID, DateTime dates, string type)
{
bool result = true;
string json = string.Empty;
var packet = new HttpPacket();
packet.building_id = buildingID;
packet.device_id = deviceID;
packet.event_time = dates.ToString("yyyy-MM-dd HH:mm:ss");
try
{
packet.elevator_number = Encoding.UTF8.GetString(recevieData.Unit);
packet.type_cd = Convert.ToChar(recevieData.STX).ToString();
packet.floor_value = Encoding.UTF8.GetString(recevieData.Location);
packet.direction_value = Convert.ToChar(recevieData.Direction).ToString();
packet.door_status = Convert.ToChar(recevieData.Door).ToString();
packet.elevator_status = Convert.ToChar(recevieData.Status).ToString();
packet.alarm_cd = Encoding.UTF8.GetString(recevieData.Alarm);
json = JsonConvert.SerializeObject(packet);
StringContent data = new StringContent(json, Encoding.UTF8, "application/json");
httpClientFactory = serviceProvider.GetService <IHttpClientFactory>();
var client = httpClientFactory.CreateClient();
client.DefaultRequestHeaders.Add("type", type);
client.Timeout = TimeSpan.FromMinutes(2);
var response = await client.PostAsync(new Uri(webappURL + "/event/elevator/status"), data);
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} [HttpClientTransfer : status] {json} Send To WebApp");
}
catch (Exception ex)
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} [status error] Data : {json}");
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} [status error] {ex.Message}");
result = false;
}
return(result);
}
public HttpResponseMessage Message(int orderId, StatusNotification value)
{
if (value.RtnCode == 2030 || value.RtnCode == 3024 || value.RtnCode == 3006)
{
_orderRepository.UpdateOrder(orderId, value.MerchantTradeNo, "090");
}
if (value.RtnCode == 2063 || value.RtnCode == 2073 || value.RtnCode == 3018)
{
_orderRepository.UpdateOrder(orderId, value.MerchantTradeNo, "110");
}
if (value.RtnCode == 3003)
{
_orderRepository.UpdateOrder(orderId, value.MerchantTradeNo, "100");
}
return(Request.CreateResponse(value.RtnCode));
}
/// <summary>
/// 엘리베이터에서 수신한 데이터를 체크하여 변동 사항 체크 메소드
/// </summary>
/// <param name="status"></param>
public Tuple <StatusNotification, DateTime> ReceiveStatus(StatusNotification status)
{
UnitData unitData = null;
//호기 추출
var unitName = Encoding.UTF8.GetString(status.Unit);
//호기 정보 조회
unitDataCollection.TryGetValue(unitName, out unitData);
Tuple <StatusNotification, DateTime> returnResult = null;
//기존에 호기 정보가 있다면, status 비교
if (unitData != null)
{
var recevieBytesData = Encoding.UTF8.GetString(status.GetByte());
var previewsBytesData = Encoding.UTF8.GetString(unitData.status.GetByte());
if (previewsBytesData.Substring(6, 5) != recevieBytesData.Substring(6, 5))
{
unitDataCollection[unitName].recevieDate = DateTime.Now;
unitDataCollection[unitName].status = status;
returnResult = new Tuple <StatusNotification, DateTime>(status, unitDataCollection[unitName].recevieDate);
}
}
else
{
UnitData unit = new UnitData();
unit.unitName = unitName;
unit.recevieDate = DateTime.Now;
unit.status = status;
unitDataCollection.TryAdd(unitName, unit);
returnResult = new Tuple <StatusNotification, DateTime>(status, unit.recevieDate);
}
return(returnResult);
}
public void ParseNotification_CreditCard_Test()
{
NotificationParser notificationParser = new NotificationParser();
StatusNotification statusNotification = null;
statusNotification = notificationParser.ParseNotification(this.creditCardNotification);
Assert.AreEqual(500, statusNotification.AmountInCents);
Assert.AreEqual(500, statusNotification.AmountPaidInCents);
Assert.IsNotNull(statusNotification.CreditCardTransaction);
Assert.IsNull(statusNotification.OnlineDebitTransaction);
Assert.AreEqual(Guid.Parse("B1B1092C-8681-40C2-A734-500F22683D9B"), statusNotification.MerchantKey);
Assert.AreEqual(Guid.Parse("18471F05-9F6D-4497-9C24-D60D5BBB6BBE"), statusNotification.OrderKey);
Assert.AreEqual("64a85875", statusNotification.OrderReference);
Assert.AreEqual(OrderStatusEnum.Paid, statusNotification.OrderStatus);
// CreditCardTransaction
CreditCardTransaction creditCardTransaction = statusNotification.CreditCardTransaction;
Assert.AreEqual("Simulator", creditCardTransaction.Acquirer);
Assert.AreEqual(500, creditCardTransaction.AmountInCents);
Assert.AreEqual("123456", creditCardTransaction.AuthorizationCode);
Assert.AreEqual(500, creditCardTransaction.AuthorizedAmountInCents);
Assert.AreEqual(500, creditCardTransaction.CapturedAmountInCents);
Assert.AreEqual("Mastercard", creditCardTransaction.CreditCardBrand);
Assert.IsTrue(string.IsNullOrEmpty(creditCardTransaction.CustomStatus));
Assert.IsNull(creditCardTransaction.RefundedAmountInCents);
Assert.AreEqual(this.ParseDateTime("2015-09-22T15:51:41.217"), creditCardTransaction.StatusChangedDate);
Assert.AreEqual("9876543210", creditCardTransaction.TransactionIdentifier);
Assert.AreEqual(Guid.Parse("4111D523-9A83-4BE3-94D2-160F1BC9C4BD"), creditCardTransaction.TransactionKey);
Assert.AreEqual("91735820", creditCardTransaction.TransactionReference);
Assert.AreEqual("63417982", creditCardTransaction.UniqueSequentialNumber);
Assert.IsNull(creditCardTransaction.VoidedAmountInCents);
Assert.AreEqual(CreditCardTransactionStatusEnum.AuthorizedPendingCapture, creditCardTransaction.PreviousCreditCardTransactionStatus);
Assert.AreEqual(CreditCardTransactionStatusEnum.Captured, creditCardTransaction.CreditCardTransactionStatus);
}
private async void RunQueryCommand_Executed(object sender, ExecutedRoutedEventArgs e)
{
Telemetry.Instance.Native?.TrackEvent("Main.RunQuery");
Telemetry.Instance.Native?.TrackMetric("RunQuery", 1);
var query = ucQueries.SelectedQueryTab.GetQuery();
try
{
var list = ucQueries.SelectedQueryTab.List;
StatusNotification.NotifyWithProgress("Quering list: " + list.Title);
var items = await ucWebs.GetClient(list.Web).ExecuteQuery(query, Config.PageSize);
ucQueries.SelectedQueryTab.QueryResult(items);
StatusNotification.Notify("Retrived items: " + items.Count);
}
catch (Exception ex)
{
StatusNotification.Notify("Quering failed");
ExceptionHandler.Handle(ex, "The request failed.");
}
}
private async void SaveButton_Click(object sender, RoutedEventArgs e)
{
if (!(sender is TextEditor textEditor))
{
textEditor = (Sets.SelectedItem as SetsViewItem)?.Content as TextEditor;
if (textEditor == null)
{
return;
}
}
StorageFile file;
if (textEditor.EditingFile == null || e is SaveAsEventArgs ||
FileSystemUtility.IsFileReadOnly(textEditor.EditingFile) ||
!await FileSystemUtility.FileIsWritable(textEditor.EditingFile))
{
file = await FilePickerFactory.GetFileSavePicker(e, textEditor, DefaultFileName).PickSaveFileAsync();
textEditor.Focus(FocusState.Programmatic);
}
else
{
file = textEditor.EditingFile;
}
if (file == null)
{
return;
}
var success = await textEditor.SaveFile(file);
if (success)
{
if (Sets.Items != null)
{
foreach (SetsViewItem setsItem in Sets.Items)
{
if (setsItem.Content != textEditor)
{
continue;
}
setsItem.Header = file.Name;
setsItem.Icon.Visibility = Visibility.Collapsed;
PathIndicator.Text = textEditor.EditingFile.Path;
LineEndingIndicator.Text =
LineEndingUtility.GetLineEndingDisplayText(textEditor.LineEnding);
EncodingIndicator.Text = textEditor.Encoding.EncodingName;
break;
}
}
StatusNotification.Show("Saved", 2000);
}
else
{
await ContentDialogFactory.GetFileSaveErrorDialog(file).ShowAsync();
}
}
public HttpResponseMessage Response(StatusNotification notification)
{
return(Request.CreateResponse(new { notification }));
}
