/// <summary>
/// Indicates whether the <see cref="DbDevice"/> differs from the <see cref="Device"/>, thereby requiring the <see cref="DbDevice"/> to be updated in the database.
/// </summary>
/// <param name="dbDevice">The <see cref="DbDevice"/> to be evaluated.</param>
/// <param name="device">The <see cref="Device"/> to compare against.</param>
/// <returns></returns>
public static bool DbDeviceRequiresUpdate(DbDevice dbDevice, Device device)
{
if (dbDevice.GeotabId != device.Id.ToString())
{
throw new ArgumentException($"Cannot compare Device '{device.Id}' with DbDevice '{dbDevice.GeotabId}' because the IDs do not match.");
}
DateTime dbDeviceActiveFromUtc = dbDevice.ActiveFrom.GetValueOrDefault().ToUniversalTime();
DateTime dbDeviceActiveToUtc = dbDevice.ActiveTo.GetValueOrDefault().ToUniversalTime();
if (dbDevice.ActiveFrom != device.ActiveFrom && dbDeviceActiveFromUtc != device.ActiveFrom)
{
return(true);
}
if (dbDevice.ActiveTo != device.ActiveTo && dbDeviceActiveToUtc != device.ActiveTo)
{
return(true);
}
string deviceDeviceType = device.DeviceType.ToString();
if (dbDevice.DeviceType != deviceDeviceType || dbDevice.Name != device.Name || dbDevice.SerialNumber != device.SerialNumber)
{
return(true);
}
return(false);
}
protected override void OnStart()
{
DbStudent dbStudent = new DbStudent();
Student student = dbStudent.GetStudent();
// Comment out the 4 lines under to deactive the GoToLogin at
if (student == null || student.accessToken == null)
{
Authenticater.Authorized = false;
}
NavPage = new NavigationPage(new MainPage());
//NavPage = new NavigationPage(new LoginPage());
MainPage = NavPage;
//NavPage.BarBackgroundColor = Color.FromHex("ec7a08");
//NavPage.BarTextColor = Color.White;
if (student != null)
{
DeleteOutdatedData();
UpdateAllFilters();
DbDevice dbDevice = new DbDevice();
if (dbDevice.GetDevice() != null && !dbDevice.GetDevice().tokenSent)
{
DevicesController dc = new DevicesController();
dc.UpdateServersDb();
}
}
}
//LOG
public int logDevice(string pDbNm, string pDevCd, string pSiteCd, string pDeviceId, string pDevTypeScd, string pDevIOScd, string pDevNm, string pIp, string pUsingFalg, string pSortNo, string pMemo, string pInputId)
{
int reCnt = 0;
DbDevice db = null;
try
{
string dbCon_IP = WebConfigurationManager.ConnectionStrings["ConnectionStr_IP"].ConnectionString;
string dbCon_DB = WebConfigurationManager.ConnectionStrings["ConnectionStr_DB"].ConnectionString;
string dbCon_USER = WebConfigurationManager.ConnectionStrings["ConnectionStr_USER"].ConnectionString;
db = new DbDevice(dbCon_IP, dbCon_DB, dbCon_USER, "0");
reCnt = db.logDevice(pDbNm, pDevCd, pSiteCd, pDeviceId, pDevTypeScd, pDevIOScd, pDevNm, pIp, pUsingFalg, pSortNo, pMemo, pInputId);
}
catch (Exception ex)
{
logs.SaveLog("[error] (page)::BizDevice.cs (Function)::logDevice (Detail)::pDbNm=[" + pDbNm + "], pDevCd=[" + pDevCd + "], pSiteCd=[" + pSiteCd + "]" +
", pDeviceId=[" + pDeviceId + "], pDevTypeScd=[" + pDevTypeScd + "], pDevIOScd=[" + pDevIOScd + "], pDevNm=[" + pDevNm + "], " +
"pIp=[" + pIp + "], pUsingFalg=[" + pUsingFalg + "], pSortNo=[" + pSortNo + "], pMemo=[" + pMemo + "], pInputId=[" + pInputId + "]", "Error");
logs.SaveLog("[error] (page)::BizDevice.cs (Function)::logDevice (Detail)::" + "\r\n" + ex.ToString(), "Error");
}
finally
{
if (db != null)
{
db.DisConnect();
}
}
return(reCnt);
}
//SELECT
public DataSet sDevice(string pDbNm, string pSiteCd)
{
DataSet ds = null;
DbDevice db = null;
try
{
string dbCon_IP = WebConfigurationManager.ConnectionStrings["ConnectionStr_IP"].ConnectionString;
string dbCon_DB = WebConfigurationManager.ConnectionStrings["ConnectionStr_DB"].ConnectionString;
string dbCon_USER = WebConfigurationManager.ConnectionStrings["ConnectionStr_USER"].ConnectionString;
db = new DbDevice(dbCon_IP, dbCon_DB, dbCon_USER, "0");
ds = db.sDevice(pDbNm, pSiteCd);
}
catch (Exception ex)
{
logs.SaveLog("[error] (page)::BizDevice.cs (Function)::sDevice (Detail)::" + "\r\n" + ex.ToString(), "Error");
}
finally
{
if (db != null)
{
db.DisConnect();
}
}
return(ds);
}
//INSERT TEAM WITH PROCEDURE
public string aDevicePro(string pDbNm, Hashtable param, out Hashtable outVal)
{
string reVal = "";
DbDevice db = null;
try
{
string dbCon_IP = WebConfigurationManager.ConnectionStrings["ConnectionStr_IP"].ConnectionString;
string dbCon_DB = "Initial Catalog=PLUS-" + pDbNm + ";";
string dbCon_USER = WebConfigurationManager.ConnectionStrings["ConnectionStr_USER"].ConnectionString;
db = new DbDevice(dbCon_IP, dbCon_DB, dbCon_USER, "1");
reVal = db.aDevicePro(param, out outVal);
}
catch (Exception ex)
{
outVal = null;
logs.SaveLog("[error] (page)::BizDevice.cs (Function)::aDevicePro (Detail)::" + "\r\n" + ex.ToString(), "Error");
}
finally
{
if (db != null)
{
db.DisConnect();
}
}
return(reVal);
}
/// <summary>
/// Converts the supplied list of <see cref="Device"/> objects into a list of <see cref="DbDevice"/> objects.
/// </summary>
/// <param name="devices">The list of <see cref="Device"/> objects to be converted.</param>
/// <returns></returns>
public static List <DbDevice> GetDbDevices(List <Device> devices)
{
var dbDevices = new List <DbDevice>();
foreach (var device in devices)
{
DbDevice dbDevice = GetDbDevice(device);
dbDevices.Add(dbDevice);
}
return(dbDevices);
}
/// <summary>
/// Inserts or update the device with the given fields.
/// </summary>
/// <param name="gcmToken"></param>
/// <param name="deviceId"></param>
/// <param name="deviceType"></param>
/// <returns></returns>
public async Task InsertOrUpdateDevice(string gcmToken, string deviceId, string deviceType)
{
DbDevice db = new DbDevice();
DbStudent dbStudent = new DbStudent();
Student student = dbStudent.GetStudent();
Device device = db.GetDevice();
if (device == null)
{
device = new Device();
device.id = deviceId;
device.token = gcmToken;
device.tokenSent = false;
device.deviceType = deviceType;
if (student != null)
{
device.username = student.username;
}
db.InsertDevice(device);
if (student != null)
{
UpdateServersDb();
}
return;
}
if (device.token != gcmToken)
{
device.token = gcmToken;
device.tokenSent = false;
if (student != null)
{
device.username = student.username;
}
db.UpdateDevice(device);
if (student != null)
{
UpdateServersDb();
}
return;
}
if (!device.tokenSent && student != null)
{
if (device.username != student.username)
{
device.username = student.username;
db.UpdateDevice(device);
}
UpdateServersDb();
}
}
/// <summary>
/// Converts the supplied <see cref="Device"/> into a <see cref="DbDevice"/>.
/// </summary>
/// <param name="device">The <see cref="Device"/> to be converted.</param>
/// <returns></returns>
public static DbDevice GetDbDevice(Device device)
{
string deviceLicensePlate = "";
string deviceLicenseState = "";
string deviceVIN = "";
dynamic convertedDevice = Convert.ChangeType(device, device.GetType());
try
{
deviceLicensePlate = convertedDevice.LicensePlate;
}
catch (RuntimeBinderException)
{
// Property does not exist for the subject Device type.
}
try
{
deviceLicenseState = convertedDevice.LicenseState;
}
catch (RuntimeBinderException)
{
// Property does not exist for the subject Device type.
}
try
{
deviceVIN = convertedDevice.VehicleIdentificationNumber;
}
catch (RuntimeBinderException)
{
// Property does not exist for the subject Device type.
}
if (deviceLicensePlate.Length == 0)
{
deviceLicensePlate = null;
}
if (deviceLicenseState.Length == 0)
{
deviceLicenseState = null;
}
if (deviceVIN.Length == 0)
{
deviceVIN = null;
}
DbDevice dbDevice = new DbDevice
{
ActiveFrom = device.ActiveFrom,
ActiveTo = device.ActiveTo,
DeviceType = device.DeviceType.ToString(),
GeotabId = device.Id.ToString(),
LicensePlate = deviceLicensePlate,
LicenseState = deviceLicenseState,
Name = device.Name,
ProductId = device.ProductId,
SerialNumber = device.SerialNumber,
VIN = deviceVIN
};
return(dbDevice);
}
public bool CreateDevice(CreateDeviceEvent device, DeviceStateEnum deviceState)
{
DbDeviceType deviceType = deviceTypesCache.First(x => string.Equals(x.Key, device.DeviceType, StringComparison.InvariantCultureIgnoreCase)).Value;
var currentUTC = DateTime.UtcNow;
var devicePayload = new CreateDevicePayload
{
ActionUTC = currentUTC,
CellModemIMEI = device.CellModemIMEI,
CellularFirmwarePartnumber = device.CellularFirmwarePartnumber,
DataLinkType = device.DataLinkType,
DeviceState = deviceState.ToString(),
DeregisteredUTC = device.DeregisteredUTC,
DevicePartNumber = device.DevicePartNumber,
DeviceSerialNumber = device.DeviceSerialNumber,
DeviceType = device.DeviceType,
DeviceUID = device.DeviceUID.Value,
FirmwarePartNumber = device.FirmwarePartNumber,
GatewayFirmwarePartNumber = device.GatewayFirmwarePartNumber,
MainboardSoftwareVersion = device.MainboardSoftwareVersion,
ModuleType = device.ModuleType,
NetworkFirmwarePartnumber = device.NetworkFirmwarePartnumber,
RadioFirmwarePartNumber = device.RadioFirmwarePartNumber,
ReceivedUTC = device.ReceivedUTC,
SatelliteFirmwarePartnumber = device.SatelliteFirmwarePartnumber
};
var devicePersonality = GetDevicePersonalities(devicePayload, null, deviceType);
devicePayload = SetNullIfPropertyEmpty(devicePayload);
//DeviceSerialNumber will be persisited as NULL in masterdata and send it as Empty to Kafka
devicePayload.DeviceSerialNumber = string.IsNullOrEmpty(devicePayload.DeviceSerialNumber) ? string.Empty : devicePayload.DeviceSerialNumber;
var deviceModel = new DbDevice
{
SerialNumber = devicePayload.DeviceSerialNumber,
DeregisteredUTC = devicePayload.DeregisteredUTC,
ModuleType = devicePayload.ModuleType,
fk_DeviceStatusID = deviceState.GetHashCode(),
MainboardSoftwareVersion = devicePayload.MainboardSoftwareVersion,
FirmwarePartNumber = devicePayload.RadioFirmwarePartNumber == null ? devicePayload.FirmwarePartNumber : devicePayload.RadioFirmwarePartNumber,
GatewayFirmwarePartNumber = devicePayload.GatewayFirmwarePartNumber,
DataLinkType = devicePayload.DataLinkType,
InsertUTC = currentUTC,
UpdateUTC = currentUTC,
fk_DeviceTypeID = deviceType.DeviceTypeID,
CellModemIMEI = devicePayload.CellModemIMEI,
DevicePartNumber = devicePayload.DevicePartNumber,
CellularFirmwarePartnumber = devicePayload.CellularFirmwarePartnumber,
NetworkFirmwarePartnumber = devicePayload.NetworkFirmwarePartnumber,
SatelliteFirmwarePartnumber = devicePayload.SatelliteFirmwarePartnumber,
DeviceUID = devicePayload.DeviceUID
};
var kafkaMessageList = new List <KafkaMessage>();
kafkaTopicNames.ForEach(topic =>
{
var kafkaMessage = new KafkaMessage()
{
Key = device.DeviceUID.ToString(),
Message = new { CreateDeviceEvent = mapper.Map <CreateDevicePayload, CreateDeviceEvent>(devicePayload) },
Topic = topic
};
kafkaMessageList.Add(kafkaMessage);
});
kafkaTopicNamesV2.ForEach(topic =>
{
var kafkaMessage = new KafkaMessage()
{
Key = device.DeviceUID.ToString(),
Message = ToDevicePayloadV2(devicePayload, devicePersonality),
Topic = topic
};
kafkaMessageList.Add(kafkaMessage);
});
var actions = new List <Action>();
actions.Add(() => transactions.Upsert(deviceModel));
actions.Add(() => transactions.Upsert <DbDevicePersonality>(devicePersonality));
actions.Add(() => transactions.Publish(kafkaMessageList));
return(transactions.Execute(actions));
}
public bool UpdateDeviceProperties(UpdateDeviceProperties device, Guid deviceUid)
{
DbDeviceType deviceType = deviceTypesCache.First(x => string.Equals(x.Key, device.DeviceType, StringComparison.InvariantCultureIgnoreCase)).Value;
var currentUTC = DateTime.UtcNow;
var devicePayload = new UpdateDevicePayload
{
ActionUTC = currentUTC,
CellularFirmwarePartnumber = device.CellularFirmwarePartnumber,
DataLinkType = device.DataLinkType,
DeviceSerialNumber = device.DeviceSerialNumber,
DeviceType = device.DeviceType,
DeviceUID = deviceUid,
GatewayFirmwarePartNumber = device.GatewayFirmwarePartNumber,
MainboardSoftwareVersion = device.MainboardSoftwareVersion,
ModuleType = device.ModuleType,
NetworkFirmwarePartnumber = device.NetworkFirmwarePartnumber,
RadioFirmwarePartNumber = device.RadioFirmwarePartNumber,
ReceivedUTC = device.ReceivedUTC,
SatelliteFirmwarePartnumber = device.SatelliteFirmwarePartnumber,
Description = device.Description
};
var existingDeviceProp = GetExistingDeviceProperties(deviceUid);
var existingPersonalities = GetExistingDevicePersonalities(devicePayload.DeviceUID);
var devicePersonality = GetDevicePersonalities(devicePayload, existingPersonalities, deviceType);
devicePayload = AppendExistingDeviceProperties(devicePayload, existingDeviceProp);
devicePayload.OwningCustomerUID = GetExistingOwningCustomerUid(deviceUid);
var deviceState = (DeviceStateEnum)Enum.Parse(typeof(DeviceStateEnum), existingDeviceProp.DeviceState, true);
devicePayload.ReceivedUTC = DateTime.UtcNow;
bool equal = CheckExistingDevicePropertiesForUpdate(devicePayload, deviceState, devicePayload.OwningCustomerUID, existingDeviceProp);
if (equal)
{
logger.LogInformation("No properties to update");
return(false);
}
else
{
var kafkaMessageList = new List <KafkaMessage>();
kafkaTopicNames.ForEach(topic =>
{
var kafkaMessage = new KafkaMessage()
{
Key = deviceUid.ToString(),
Message = new { UpdateDeviceEvent = mapper.Map <UpdateDevicePayload, UpdateDeviceEvent>(devicePayload) },
Topic = topic
};
kafkaMessageList.Add(kafkaMessage);
});
kafkaTopicNamesV2.ForEach(topic =>
{
var kafkaMessage = new KafkaMessage()
{
Key = deviceUid.ToString(),
Message = ToDevicePayloadV2(devicePayload, devicePersonality),
Topic = topic
};
kafkaMessageList.Add(kafkaMessage);
});
var actions = new List <Action>();
var deviceModel = new DbDevice
{
CellModemIMEI = devicePayload.CellModemIMEI,
CellularFirmwarePartnumber = devicePayload.CellularFirmwarePartnumber,
DataLinkType = devicePayload.DataLinkType,
DeregisteredUTC = devicePayload.DeregisteredUTC,
DevicePartNumber = devicePayload.DevicePartNumber,
SerialNumber = devicePayload.DeviceSerialNumber,
fk_DeviceTypeID = deviceType.DeviceTypeID,
DeviceUID = devicePayload.DeviceUID,
FirmwarePartNumber = devicePayload.RadioFirmwarePartNumber == null ? devicePayload.FirmwarePartNumber : devicePayload.RadioFirmwarePartNumber,
GatewayFirmwarePartNumber = devicePayload.GatewayFirmwarePartNumber,
MainboardSoftwareVersion = devicePayload.MainboardSoftwareVersion,
ModuleType = devicePayload.ModuleType,
NetworkFirmwarePartnumber = devicePayload.NetworkFirmwarePartnumber,
SatelliteFirmwarePartnumber = devicePayload.SatelliteFirmwarePartnumber,
UpdateUTC = currentUTC,
fk_DeviceStatusID = deviceState.GetHashCode()
};
actions.Add(() => transactions.Upsert(deviceModel));
actions.Add(() => transactions.Upsert <DbDevicePersonality>(devicePersonality));
actions.Add(() => transactions.Publish(kafkaMessageList));
return(transactions.Execute(actions));
}
}
public bool UpdateDevice(UpdateDeviceEvent device, DeviceStateEnum deviceState)
{
var currentUTC = DateTime.UtcNow;
var devicePayload = new UpdateDevicePayload
{
ActionUTC = currentUTC,
CellModemIMEI = device.CellModemIMEI,
CellularFirmwarePartnumber = device.CellularFirmwarePartnumber,
DataLinkType = device.DataLinkType,
DeregisteredUTC = device.DeregisteredUTC,
DevicePartNumber = device.DevicePartNumber,
DeviceSerialNumber = device.DeviceSerialNumber,
DeviceState = deviceState == DeviceStateEnum.None?null: deviceState.ToString(),
DeviceType = device.DeviceType,
DeviceUID = device.DeviceUID.Value,
FirmwarePartNumber = device.FirmwarePartNumber,
GatewayFirmwarePartNumber = device.GatewayFirmwarePartNumber,
MainboardSoftwareVersion = device.MainboardSoftwareVersion,
ModuleType = device.ModuleType,
NetworkFirmwarePartnumber = device.NetworkFirmwarePartnumber,
OwningCustomerUID = device.OwningCustomerUID,
RadioFirmwarePartNumber = device.RadioFirmwarePartNumber,
ReceivedUTC = device.ReceivedUTC,
SatelliteFirmwarePartnumber = device.SatelliteFirmwarePartnumber
};
var existingDeviceProp = GetExistingDeviceProperties(device.DeviceUID.Value);
if (PLDeviceTypes.Contains(device.DeviceType.ToLower(), StringComparer.InvariantCultureIgnoreCase))
{
existingDeviceProp.RadioFirmwarePartNumber = existingDeviceProp.FirmwarePartNumber;
existingDeviceProp.FirmwarePartNumber = null;
}
var existingPersonalities = GetExistingDevicePersonalities(device.DeviceUID.Value);
DbDeviceType deviceType = string.IsNullOrEmpty(devicePayload.DeviceType) ? deviceTypesCache.First(x => string.Equals(x.Key, existingDeviceProp.DeviceType, StringComparison.InvariantCultureIgnoreCase)).Value : deviceTypesCache.First(x => string.Equals(x.Key, devicePayload.DeviceType, StringComparison.InvariantCultureIgnoreCase)).Value;
var devicePersonality = GetDevicePersonalities(devicePayload, existingPersonalities, deviceType);
devicePayload = AppendExistingDeviceProperties(devicePayload, existingDeviceProp);
Guid?currentOwningCustomerUID = GetExistingOwningCustomerUid(device.DeviceUID.Value);
devicePayload.OwningCustomerUID = devicePayload.OwningCustomerUID ?? currentOwningCustomerUID;
//DeviceSerialNumber will be persisited as NULL in masterdata and send it as Empty to Kafka
devicePayload.DeviceSerialNumber = string.IsNullOrEmpty(devicePayload.DeviceSerialNumber) ? string.Empty : devicePayload.DeviceSerialNumber;
bool equal = CheckExistingDevicePropertiesForUpdate(devicePayload, (DeviceStateEnum)Enum.Parse(typeof(DeviceStateEnum), devicePayload.DeviceState), currentOwningCustomerUID, existingDeviceProp);
if (equal)
{
logger.LogInformation("No properties to update");
return(false);
}
else
{
var kafkaMessageList = new List <KafkaMessage>();
kafkaTopicNames.ForEach(topic =>
{
var kafkaMessage = new KafkaMessage()
{
Key = device.DeviceUID.ToString(),
Message = new { UpdateDeviceEvent = mapper.Map <UpdateDevicePayload, UpdateDeviceEvent>(devicePayload) },
Topic = topic
};
kafkaMessageList.Add(kafkaMessage);
});
kafkaTopicNamesV2.ForEach(topic =>
{
var kafkaMessage = new KafkaMessage()
{
Key = device.DeviceUID.ToString(),
Message = ToDevicePayloadV2(devicePayload, devicePersonality),
Topic = topic
};
kafkaMessageList.Add(kafkaMessage);
});
List <Action> actions = new List <Action>();
var deviceModel = new DbDevice
{
CellModemIMEI = devicePayload.CellModemIMEI,
CellularFirmwarePartnumber = devicePayload.CellularFirmwarePartnumber,
DataLinkType = devicePayload.DataLinkType,
DeregisteredUTC = devicePayload.DeregisteredUTC,
DevicePartNumber = devicePayload.DevicePartNumber,
SerialNumber = devicePayload.DeviceSerialNumber,
fk_DeviceStatusID = deviceState.GetHashCode(),
fk_DeviceTypeID = deviceType.DeviceTypeID,
DeviceUID = devicePayload.DeviceUID,
FirmwarePartNumber = devicePayload.RadioFirmwarePartNumber == null ? devicePayload.FirmwarePartNumber : devicePayload.RadioFirmwarePartNumber,
GatewayFirmwarePartNumber = devicePayload.GatewayFirmwarePartNumber,
MainboardSoftwareVersion = devicePayload.MainboardSoftwareVersion,
ModuleType = devicePayload.ModuleType,
NetworkFirmwarePartnumber = devicePayload.NetworkFirmwarePartnumber,
SatelliteFirmwarePartnumber = devicePayload.SatelliteFirmwarePartnumber,
UpdateUTC = currentUTC
};
var asset = GetOwningCustomerUID(device.DeviceUID.Value);
if (device.OwningCustomerUID.HasValue && asset != null && (asset.OwningCustomerUID == Guid.Empty || !device.OwningCustomerUID.Equals(asset.OwningCustomerUID)))
{
var updateAsset = new UpdateAssetEvent
{
AssetName = asset.AssetName,
AssetType = asset.AssetType,
EquipmentVIN = asset.EquipmentVIN,
IconKey = asset.IconKey,
Model = asset.Model,
ModelYear = asset.ModelYear,
LegacyAssetID = asset.LegacyAssetID,
AssetUID = asset.AssetUID,
OwningCustomerUID = device.OwningCustomerUID.Value,
ActionUTC = DateTime.UtcNow,
ReceivedUTC = DateTime.UtcNow
};
actions.Add(() => assetServices.UpdateAsset(updateAsset));
}
actions.Add(() => transactions.Upsert(deviceModel));
actions.Add(() => transactions.Upsert <DbDevicePersonality>(devicePersonality));
actions.Add(() => transactions.Publish(kafkaMessageList));
return(transactions.Execute(actions));
}
}
public async Task UpdateServersDb()
{
DbDevice db = new DbDevice();
DbStudent dbStudent = new DbStudent();
Student student = dbStudent.GetStudent();
Device device = db.GetDevice();
string accessToken = dbStudent.GetStudentAccessToken();
if (student == null || accessToken == null || device == null || student.username != device.username)
{
Authenticater.Authorized = false;
return;
}
if (device.tokenSent)
{
return;
}
System.Diagnostics.Debug.WriteLine("DevicesController - UpdateServersDb - bearer: " + accessToken);
string serializedJson = "{\"Device\":[{\"id\":\"" + device.id + "\"," + "\"token\":\"" + device.token + "\"," +
"\"deviceType\":\"" + device.deviceType + "\"}]}";
// {"Device":[{"id":"HT451WM08832","token":"longGCMToken","deviceType":"android"}]}
System.Diagnostics.Debug.WriteLine("DevicesController - UpdateServersDb serializedJson: " + serializedJson);
string encodedUsername = Hasher.Base64Encode(student.username);
//"api/v1/students/{id}"
string updateAdress = studentAdress + "/" + encodedUsername;
System.Diagnostics.Debug.WriteLine("DevicesController - UpdateServersDb - adress: " + updateAdress);
Uri url = new Uri(updateAdress);
System.Diagnostics.Debug.WriteLine("DevicesController - UpdateServersDb - url.ToString: " + url.ToString());
var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);
var content = new StringContent(serializedJson, Encoding.UTF8, "application/json");
try
{
var response = await client.PostAsync(url, content);
System.Diagnostics.Debug.WriteLine("UpdateServersDb response " + response.StatusCode.ToString());
if (response.StatusCode == HttpStatusCode.OK)
{
device.tokenSent = true;
db.UpdateDevice(device);
return;
}
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
System.Diagnostics.Debug.WriteLine("DevicesController - UpdateServersDb failed due to lack of Authorization");
Authenticater.Authorized = false;
}
// response.StatusCode is either unauthorized or another failed status.
return;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("StudentsController - PostStudentsStudyGroupToServer: await client.PostAsJsonAsync(url, jsonString) Failed");
System.Diagnostics.Debug.WriteLine("StudentsController - PostStudentsStudyGroupToServer: Exception msg: " + e.Message);
System.Diagnostics.Debug.WriteLine("StudentsController - PostStudentsStudyGroupToServer: Stack Trace: \n" + e.StackTrace);
System.Diagnostics.Debug.WriteLine("StudentsController - PostStudentsStudyGroupToServer: End Of Stack Trace");
return;
}
}
/// <summary>
/// This method is called after authentication is successfull.
/// Implement functionality that is useful as initial server communication.
/// </summary>
/// <param name="account"></param>
async void PerformAuth2TestRequests(Account account)
{
Authorized = true;
App.SuccessfulLoginAction();
try
{
/*
* System.Diagnostics.Debug.WriteLine("PerformAuth2TestRequests before looop");
*
*
* foreach (KeyValuePair<string, string> p in account.Properties)
* {
* System.Diagnostics.Debug.WriteLine("Property: Key:" + p.Key + " Value:" + p.Value);
* }
* System.Diagnostics.Debug.WriteLine("PerformAuth2TestRequests before looop");
*
* System.Diagnostics.Debug.WriteLine("PerformAuth2TestRequests: Url:" + AuthProvider.ApiRequests);
* System.Diagnostics.Debug.WriteLine("Request Url:" + AuthProvider.ApiRequests);
*/
Uri requestLocalToken = new Uri(AuthProvider.ApiRequests + account.Properties["access_token"]);
System.Diagnostics.Debug.WriteLine("Requesting local token");
System.Diagnostics.Debug.WriteLine("Using access_token: " + account.Properties["access_token"]);
OAuth2Request request1 = new OAuth2Request("GET", requestLocalToken, null, account);
//OAuth2Request request1 = new OAuth2Request("GET", requestLocalToken, null, null);
IResponse response1 = await request1.GetResponseAsync();
System.Diagnostics.Debug.WriteLine("After Response");
Dictionary <string, string> responseDict = JsonConvert.DeserializeObject <Dictionary <string, string> >(response1.GetResponseText());
string localToken = "";
string username = "";
if (response1.StatusCode == 200)
{
System.Diagnostics.Debug.WriteLine("Response code from backend: 200");
localToken = responseDict["access_token"];
username = responseDict["userName"];
System.Diagnostics.Debug.WriteLine("username: "******"localToken: " + localToken);
StudentsController sc = new StudentsController();
DbStudent dbStudent = new DbStudent();
if (dbStudent.CheckIfStudentExist(username))
{
System.Diagnostics.Debug.WriteLine("Student did exist");
Student student = dbStudent.GetStudent(username);
student.accessToken = localToken;
dbStudent.UpdateStudent(student);
DevicesController dc = new DevicesController();
dc.UpdateServersDb();
}
else
{
System.Diagnostics.Debug.WriteLine("Student did not exist");
dbStudent.DeleteAllStudents();
Student student = new Student();
student.username = username;
student.accessToken = localToken;
student.receiveNotifications = true;
student.receiveJobNotifications = true;
student.receiveProjectNotifications = true;
dbStudent.InsertStudent(student);
DevicesController dc = new DevicesController();
DbDevice dbDevice = new DbDevice();
dbDevice.FixStudentForeignKey(username);
dc.UpdateServersDb();
}
}
/*
* string studentEndpoint = "http://kompetansetorgetserver1.azurewebsites.net/api/v1/students";
* Uri testAuthorize = new Uri(studentEndpoint);
*
*
* //authorization: bearer b2Dvqzi9Ux_FAjbBYat6PE-LgNGKL_HDBWbnJ3Fb9cwfjaE8NQdqcvC8jwSB5QJUIVRog_gQQPjaRI0DT7ahu7TEpqP28URtPr1LjgaV - liCqgIuTdSHW_NqD3qh - 5shVh - h7TCin7XNHq8GSkGg5qtOlcHeFPSZ4xMwMbw5_1rBfKYJr3w0_D5R9jk0hJPEfJldCTYcawatz7wVfbmz0qKHAkrKxZyaqum6IHJWdczWz5K26RCfZWMwEmK1uLN5
*
* var client = new HttpClient();
* System.Diagnostics.Debug.WriteLine("PerformAuth2TestRequests before Setting AuthenticationHeaderValue");
* client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", localToken);
* System.Diagnostics.Debug.WriteLine("PerformAuth2TestRequests after Setting AuthenticationHeaderValue");
* System.Diagnostics.Debug.WriteLine(client.DefaultRequestHeaders.Authorization.Parameter);
*
*
* var response = await client.GetAsync(testAuthorize);
*
*
* System.Diagnostics.Debug.WriteLine("PerformAuth2TestRequests: StatusCode:" + response.StatusCode);
* // + " ResponseUri:" + response.ResponseUri);
* //System.Diagnostics.Debug.WriteLine("PerformAuth2TestRequests: Headers:");
*
*
* foreach (KeyValuePair<string, string> h in response.Headers)
* {
* System.Diagnostics.Debug.WriteLine("Header: Key:" + h.Key + " Value:" + h.Value);
* }
* System.Diagnostics.Debug.WriteLine("Response(" + response.StatusCode);
* string jsonString = await response.Content.ReadAsStringAsync();
* System.Diagnostics.Debug.WriteLine(jsonString);
*/
// TODO Implement relevant GET, PUT or POST Requests
// Notifies the app that the login was successful and that its safe to shift page.
Authorized = true;
App.SuccessfulLoginAction();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Exception: PerformAuth2TestRequests: Message:" + ex.Message);
foreach (KeyValuePair <string, string> p in account.Properties)
{
System.Diagnostics.Debug.WriteLine("Key:" + p.Key + " Value:" + p.Value);
}
}
}
public async Task <IActionResult> PostNew([FromBody] NewDeviceDto newDeviceDto)
{
_logger.LogDebug("PostNewDevice");
try
{
using (var context = new DynamoDBContext(_dynamoDb)) {
var now = DateTime.UtcNow;
// First create user if it doesn't exist
var user = await context.LoadAsync <DbUser>(newDeviceDto.User);
if (user == null)
{
user = new DbUser {
Id = newDeviceDto.User,
RegisterDate = now,
Email = "",
Name = ""
};
await context.SaveAsync(user);
}
// Try to load device
var existingDevice = await context.LoadAsync <DbDevice>(newDeviceDto.Id);
if (existingDevice == null)
{
// Create new device
var newDevice = new DbDevice {
Id = newDeviceDto.Id,
User = newDeviceDto.User,
Description = newDeviceDto.Description,
Enabled = newDeviceDto.Enabled,
RegisterDate = now,
UpdateDate = now,
};
await context.SaveAsync(newDevice);
return(Ok(new {
result = "ok",
message = "Created device.",
device = newDevice
}));
}
else
{
// Update device
existingDevice.Enabled = newDeviceDto.Enabled;
existingDevice.UpdateDate = now;
existingDevice.Description = newDeviceDto.Description;
await context.SaveAsync(existingDevice);
return(Ok(new {
result = "ok",
message = "Updated device.",
device = existingDevice
}));
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
throw;
}
}
