public virtual DataAccessResult <TEntity> Update(TEntity entityToUpdate,
EntityState newChildrenState = EntityState.Unchanged)
{
var result = new DataAccessResult <TEntity>();
try
{
//If entityToUpdate is already being tracked, then we want to use a different method for updating the entity, so check that here
if (MainEntity.Local.Any(e => e.Id.Equals(entityToUpdate.Id)))
{
var existingEntity = GetEntity(entityToUpdate.Id);
DbContext.Entry(existingEntity).CurrentValues.SetValues(entityToUpdate);
}
else
{
DbContext.Entry(entityToUpdate).State = EntityState.Modified;
}
SetExistingChildrenStateTo(newChildrenState, entityToUpdate);
result.IsSuccessful = true;
result.Data = entityToUpdate;
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.Error = ErrorValues.GENERIC_FATAL_BACKEND_ERROR;
Logger.Error(GetFormattedGenericLogMessage(GENERIC_UPDATE_LOG_MESSAGE), ex);
}
return(result);
}
protected override void zExecuteStep()
{
string command = DataUtils.ApplyStateVariablesToString(m_Step.Command, CurrentScope.DataScope, m_Step.TrimVariableValueWhitespace);
using (IDataAccess dataAccess = DataAccessFactory.CreateDataAccess(m_Step.ConnectionType, m_Step.ConnectionString))
{
DataAccessResult result;
if (m_Step.ResultMapping is ScalarResultMapping)
{
DataAccessResult <object> scalarResult = dataAccess.ExecuteScalar(m_Step.CommandType, command, paramBuilder => zCreateInputParameters(paramBuilder));
zReadScalarResult(scalarResult.Value);
result = scalarResult;
}
else if (m_Step.ResultMapping is TableResultMapping)
{
result = dataAccess.ExecuteQueryReader(m_Step.CommandType, command,
paramBuilder => zCreateInputParameters(paramBuilder),
reader => zReadTableResult(reader));
}
else
{
result = dataAccess.ExecuteNonQuery(m_Step.CommandType, command, paramBuilder => zCreateInputParameters(paramBuilder));
}
zReadOutputParameters(result.OutputParameters);
}
zCompleteStep(StepResult.Success);
}
public async virtual Task <DataAccessResult <TEntity> > GetWhereAsync(Expression <Func <TEntity, bool> > predicate,
params string[] includes)
{
var result = new DataAccessResult <TEntity>();
try
{
var subset = await
MainEntity.IncludeMany(includes)
.AsExpandable()
.Where(predicate)
.SingleOrDefaultAsync();
result.Data = subset;
result.IsSuccessful = true;
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.Error = ErrorValues.GENERIC_FATAL_BACKEND_ERROR;
Logger.Error(GetFormattedGenericLogMessage(GENERIC_GET_WHERE_LOG_MESSAGE), ex);
}
return(result);
}
private async Task <string> StartInitializeUserAsync(SignInContext signInContext, IAsyncCollector <EventGridEvent> collector, ILogger log)
{
string id = Guid.NewGuid().ToString();
string location = $"{serviceBaseAddress}/UserInit/{id}";
UserInitializeStatus status = new UserInitializeStatus(id, false);
DataAccessResult entryAddResult = await dataService.SetUserInitializeStatusAsync(status);
if (!entryAddResult.Success)
{
log.LogWarning("Cannot add user initialize status to database. Status {statusCode}", entryAddResult.StatusCode);
}
try
{
var eventGridEvent = new EventGridEvent(
id: $"UserInit-{Guid.NewGuid()}",
subject: signInContext.SignedInUser,
data: new Models.UserInitializeCommand(signInContext, id),
eventType: "DL444.Ucqu.UserInit",
eventTime: DateTime.UtcNow,
dataVersion: "1.0"
);
await collector.AddAsync(eventGridEvent);
}
catch (Exception ex)
{
log.LogError(ex, "Cannot trigger user initialization.");
}
return(location);
}
public virtual DataAccessResult <List <TEntity> > GetAllWhereOrdered(
Expression <Func <TEntity, bool> > predicate,
string orderBy, bool descending,
params string[] includes)
{
var result = new DataAccessResult <List <TEntity> >();
try
{
var builder = MainEntity.IncludeMany(includes).AsExpandable().Where(predicate);
builder = @descending ? builder.OrderBy("it." + orderBy + " descending") : builder.OrderBy("it." + orderBy);
var allOrderedEntities = builder.ToList();
result.IsSuccessful = true;
result.Data = allOrderedEntities;
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.Error = ErrorValues.GENERIC_FATAL_BACKEND_ERROR;
Logger.Error(GetFormattedGenericLogMessage(GENERIC_GET_ALL_WHERE_ORDERED_LOG_MESSAGE), ex);
}
return(result);
}
private bool RecordExistsCheck(SQLiteCommand cmd, IExpenseTypeModel expenseTypeModel)
{
Int32 countOfRecsFound = 0;
bool RecordExistsCheckPassed = true;
DataAccessResult dataAccessResult = new DataAccessResult();
cmd.Prepare();
cmd.CommandText = "Select count(*) from ExpenseType where ExpenseTypeName=@ExpenseTypeName";
cmd.Parameters.AddWithValue("@ExpenseTypeName", expenseTypeModel.ExpenseTypeName);
try
{
countOfRecsFound = Convert.ToInt32(cmd.ExecuteScalar());
}
catch (SQLiteException e)
{
string msg = e.Message;
throw;
}
if (countOfRecsFound > 0)
{
dataAccessResult.Status = "Error";
RecordExistsCheckPassed = false;
throw new DataAccessException(dataAccessResult);
}
return(RecordExistsCheckPassed);
}
public async Task <DataAccessResult <List <string> > > GetUsersAsync()
{
int userCount = 0;
QueryDefinition countQuery = new QueryDefinition("SELECT COUNT(c) AS ItemCount FROM c WHERE c.pk = \"Credential\"");
await foreach (Models.CountHeader header in container.GetItemQueryIterator <Models.CountHeader>(countQuery, requestOptions: new QueryRequestOptions()
{
PartitionKey = new PartitionKey("Credential")
}))
{
userCount = header.ItemCount;
}
if (userCount == 0)
{
return(DataAccessResult <List <string> > .Ok(new List <string>()));
}
var users = new List <string>(userCount);
QueryDefinition usersQuery = new QueryDefinition("SELECT c.Resource.StudentId FROM c WHERE c.pk = \"Credential\"");
await foreach (Models.StudentIdHeader header in container.GetItemQueryIterator <Models.StudentIdHeader>(usersQuery, requestOptions: new QueryRequestOptions()
{
PartitionKey = new PartitionKey("Credential")
}))
{
users.Add(header.StudentId);
}
return(DataAccessResult <List <string> > .Ok(users));
}
public async Task <DataAccessResult> RemovePushChannelAsync(string username, PushPlatform platform, IEnumerable <string> channelIdentifiers)
{
DataAccessResult <NotificationChannelCollection> fetchResult = await GetPushChannelsAsync(username, platform);
NotificationChannelCollection collection;
if (fetchResult.Success)
{
collection = fetchResult.Resource;
}
else
{
return(new DataAccessResult(false, fetchResult.StatusCode));
}
int removedCount = 0;
foreach (string id in channelIdentifiers)
{
removedCount += collection.Channels.RemoveAll(x => x.ChannelIdentifier.Equals(id, StringComparison.Ordinal));
}
if (removedCount == 0)
{
return(new DataAccessResult(false, 404));
}
return(await SetResourceAsync(collection));
}
public async Task <DataAccessResult> AddPushChannelAsync(string username, PushPlatform platform, string channelIdentifier)
{
DataAccessResult <NotificationChannelCollection> fetchResult = await GetPushChannelsAsync(username, platform);
NotificationChannelCollection collection;
if (fetchResult.Success)
{
collection = fetchResult.Resource;
}
else if (fetchResult.StatusCode == 404)
{
collection = new NotificationChannelCollection(username, platform);
}
else
{
return(new DataAccessResult(false, fetchResult.StatusCode));
}
if (collection.Channels.Exists(x => x.ChannelIdentifier.Equals(channelIdentifier, StringComparison.Ordinal)))
{
return(DataAccessResult.Ok);
}
collection.Channels.Add(new NotificationChannelItem(channelIdentifier));
if (collection.Channels.Count > maxChannelCountPerPlatform)
{
collection.Channels.RemoveAt(0);
}
return(await SetResourceAsync(collection));
}
public async Task SendNotificationAsync(string username, Func <WindowsPushNotification> notificationFunc, ILogger log)
{
Task <string?> tokenTask = GetTokenAsync(log);
DataAccessResult <NotificationChannelCollection> channelResult = await dataService.GetPushChannelsAsync(username, Platform);
if (channelResult.StatusCode == 404)
{
return;
}
else if (!channelResult.Success)
{
log.LogError("Failed to fetch WNS channels from databse. Username: {username}", username);
}
string?token = await tokenTask;
if (token == null)
{
return;
}
List <string> channelsToRemove = new List <string>();
for (int i = 0; i < channelResult.Resource.Channels.Count; i++)
{
string channel = channelResult.Resource.Channels[i].ChannelIdentifier;
if (!new Uri(channel).Host.EndsWith(validChannelHost, StringComparison.Ordinal))
{
log.LogWarning("Invalid channel found. Channel URI: {channelUri}", channel);
channelsToRemove.Add(channel);
continue;
}
WindowsPushNotification notification = notificationFunc();
if (notification.Type == WindowsNotificationType.Raw)
{
throw new NotSupportedException($"Notification type {notification.Type} is not currently supported.");
}
HttpRequestMessage request = CreateRequest(token, channel, notification);
HttpResponseMessage response = await httpClient.SendAsync(request);
if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
token = await RenewTokenAsync(log);
if (token == null)
{
return;
}
i--;
}
else if (response.StatusCode == System.Net.HttpStatusCode.NotFound || response.StatusCode == System.Net.HttpStatusCode.Gone)
{
channelsToRemove.Add(channel);
}
else if (!response.IsSuccessStatusCode)
{
log.LogWarning("Failed to send notification to WNS server. Username: {username}", username);
}
}
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "UserInit/{id}")] HttpRequest req,
string id,
ILogger log)
{
if (string.IsNullOrWhiteSpace(id))
{
return(new BadRequestResult());
}
DataAccessResult <UserInitializeStatus> result = await dataService.GetUserInitializeStatusAsync(id);
if (result.Success)
{
if (result.Resource.Completed)
{
return(new OkObjectResult(new BackendResult <UserInitializeStatus>(result.Resource)));
}
else
{
return(new AcceptedResult($"{serviceBaseAddress}/UserInit/{id}", new BackendResult <UserInitializeStatus>(true, result.Resource, locService.GetString("UserInitPrepare"))));
}
}
else
{
return(new NotFoundResult());
}
}
public IEnumerable <MonthCategoryCost> GetTotalCostPerCategoryAndMonth(int year, int month, int UserId)
{
List <MonthCategoryCost> list = new List <MonthCategoryCost>();
DataAccessResult dataAccessResult = new DataAccessResult();
string sql = "SELECT Expense.ExpenseTypeId, " +
"ExpenseType.ExpenseTypeName, " +
"SUM(Cost) as TotalCost " +
"from Expense INNER JOIN ExpenseType " +
"ON Expense.ExpenseTypeId = ExpenseType.ExpenseTypeId " +
"WHERE UserId = @UserId AND strftime('%Y', Expense.Date) = @Year AND strftime('%m', Expense.Date) = @Month " +
"GROUP BY Expense.ExpenseTypeId";
using (SQLiteConnection connection = new SQLiteConnection(_connectionString))
{
try
{
connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(sql, connection))
{
cmd.CommandText = sql;
cmd.Prepare();
cmd.Parameters.Add(new SQLiteParameter("@UserId", UserId));
cmd.Parameters.Add(new SQLiteParameter("@Year", year.ToString()));
cmd.Parameters.Add(new SQLiteParameter("@Month", month.ToString("00")));
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
MonthCategoryCost item = new MonthCategoryCost();
item.ExpenseTypeId = Int32.Parse(reader["ExpenseTypeId"].ToString());
item.ExpenseTypeName = reader["ExpenseTypeName"].ToString();
item.TotalCost = Double.Parse(reader["TotalCost"].ToString());
list.Add(item);
}
}
}
}
catch (SQLiteException e)
{
dataAccessResult.setValues(
status: "Error",
operationSucceeded: false,
exceptionMessage: e.Message,
customMessage: "Greška kod dohvata zapisa o trošku za zadani mjesec i kategoriju [Expense->GetTotalCostPerCategoryAndMonth]",
helpLink: e.HelpLink,
errorCode: e.ErrorCode,
stackTrace: e.StackTrace);
throw new DataAccessException(e.Message, e.InnerException, dataAccessResult);
}
}
return(list);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "notifyChannel/windows")] HttpRequest req,
[UserIdentity] string?username,
ILogger log)
{
if (username == null)
{
return(new UnauthorizedResult());
}
NotificationChannelItem channel;
try
{
channel = await JsonSerializer.DeserializeAsync <NotificationChannelItem>(req.Body);
}
catch (JsonException)
{
return(new BadRequestResult());
}
if (!Uri.TryCreate(channel.ChannelIdentifier, UriKind.Absolute, out Uri? uri) || !uri.Host.EndsWith(validChannelHost, StringComparison.Ordinal))
{
return(new BadRequestResult());
}
DataAccessResult <StudentCredential> userFetchResult = await userDataService.GetCredentialAsync(username);
if (userFetchResult.StatusCode == 404)
{
return(new UnauthorizedResult());
}
else if (!userFetchResult.Success)
{
log.LogError("Cannot fetch user information from database. Status: {statusCode}", userFetchResult.StatusCode);
return(new ObjectResult(new BackendResult <object>(false, new object(), null))
{
StatusCode = 503
});
}
DataAccessResult result = await pushDataService.AddPushChannelAsync(username, PushPlatform.Wns, channel.ChannelIdentifier);
if (result.Success)
{
return(new OkObjectResult(new BackendResult <object>(new object())));
}
else
{
log.LogError("Cannot write notification channel to database. Status: {statusCode}", result.StatusCode);
return(new ObjectResult(new BackendResult <object>(false, new object(), null))
{
StatusCode = 503
});
}
}
public async Task <IActionResult> RunGet(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "Calendar/{username}/{id}")] HttpRequest req,
string?username,
string?id,
ILogger log)
{
if (username == null || id == null)
{
return(new BadRequestResult());
}
Task <DataAccessResult <Schedule> > scheduleFetchTask = dataService.GetScheduleAsync(username);
Task <DataAccessResult <ExamSchedule> > examsFetchTask = dataService.GetExamsAsync(username);
DataAccessResult <StudentInfo> userFetchResult = await dataService.GetStudentInfoAsync(username);
if (!userFetchResult.Success)
{
if (userFetchResult.StatusCode == 404)
{
return(new OkObjectResult(calService.GetEmptyCalendar()));
}
else
{
log.LogWarning("Failed to fetch user info from database. Status {statusCode}", userFetchResult.StatusCode);
return(new StatusCodeResult(503));
}
}
if (!id.Equals(userFetchResult.Resource.CalendarSubscriptionId))
{
return(new OkObjectResult(calService.GetEmptyCalendar()));
}
DataAccessResult <Schedule> scheduleFetchResult = await scheduleFetchTask;
if (!scheduleFetchResult.Success)
{
log.LogError("Failed to fetch schedule from database. Status {statusCode}", scheduleFetchResult.StatusCode);
return(new StatusCodeResult(503));
}
DataAccessResult <ExamSchedule> examsFetchResult = await examsFetchTask;
ExamSchedule?exams;
if (examsFetchResult.Success)
{
exams = examsFetchResult.Resource;
}
else
{
exams = null;
log.LogError("Failed to fetch exams from database. Status {statusCode}", examsFetchResult.StatusCode);
}
return(new OkObjectResult(calService.GetCalendar(scheduleFetchResult.Resource, exams, 15)));
}
private async Task <DataAccessResult <T> > GetResourceAsync <T>(string id, string partitionKey) where T : ICosmosResource
{
try
{
ItemResponse <CosmosResource <T> > result = await container.ReadItemAsync <CosmosResource <T> >(id, new PartitionKey(partitionKey));
return(DataAccessResult <T> .Ok(result.Value.Resource));
}
catch (CosmosException ex)
{
return(new DataAccessResult <T>(false, default(T), ex.Status));
}
}
public DataAccessResult ModifySickness(Sickness sickness, int[] habitList, int[] adviceList, int[] areaList)
{
var result = new DataAccessResult();
var filterHabitList = from x in DbContext.Habits where habitList.Any(y => y == x.Id) select x;
// Clear exsiting habits
sickness.Habits = new List <Habit>();
// Add new habits
filterHabitList.ToList().ForEach(x => sickness.Habits.Add(x));
var filterAdviceList = from x in DbContext.Advice where adviceList.Any(y => y == x.Id) select x;
sickness.Advice = new List <Advice>();
filterAdviceList.ToList().ForEach(x => sickness.Advice.Add(x));
var filterAreaList = from x in DbContext.Areas where areaList.Any(y => y == x.Id) select x;
sickness.Areas = new List <Area>();
filterAreaList.ToList().ForEach(x => sickness.Areas.Add(x));
try
{
DbContext.Set <Sickness>().Attach(sickness);
DbContext.Entry(sickness).State = EntityState.Modified;
if (DbContext.SaveChanges() > 0)
{
result.ResultCode = ResultCodeOption.Ok;
result.Message = DataAccessResult.SuccessDefaultString;
}
}
catch (DbEntityValidationException dbEx)
{
LogHelper.Log.Error($"{GetType().Name} exception.", dbEx);
result.ResultCode = ResultCodeOption.ValidationFailure;
result.Message = dbEx.InnerException?.InnerException?.Message;
}
catch (DbUpdateException dbEx)
{
LogHelper.Log.Error($"{GetType().Name} exception.", dbEx);
result.ResultCode = ResultCodeOption.Duplicate;
result.Message = dbEx.InnerException?.InnerException?.Message;
}
catch (Exception dbEx)
{
LogHelper.Log.Error($"{GetType().Name} exception.", dbEx);
result.Message = dbEx.GetType().ToString();
}
return(result);
}
public IEnumerable <IExpenseModel> GetAllByUserIdAndExpenseType(int UserId, IExpenseTypeModel expenseTypeModel)
{
List <ExpenseModel> list = new List <ExpenseModel>();
DataAccessResult dataAccessResult = new DataAccessResult();
string sql = "SELECT * FROM Expense WHERE Expense.UserId = @UserId AND Expense.ExpenseTypeId = @ExpenseTypeId";
using (SQLiteConnection connection = new SQLiteConnection(_connectionString))
{
try
{
connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(sql, connection))
{
cmd.CommandText = sql;
cmd.Prepare();
cmd.Parameters.Add(new SQLiteParameter("@ExpenseTypeId", expenseTypeModel.ExpenseTypeId));
cmd.Parameters.Add(new SQLiteParameter("@UserId", UserId));
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
ExpenseModel expenseModel = new ExpenseModel();
expenseModel.ExpenseId = Int32.Parse(reader["ExpenseId"].ToString());
expenseModel.ExpenseTypeId = Int32.Parse(reader["ExpenseTypeId"].ToString());
expenseModel.Date = reader["Date"].ToString();
expenseModel.Cost = Double.Parse(reader["Cost"].ToString());
list.Add(expenseModel);
}
}
}
}
catch (SQLiteException e)
{
dataAccessResult.setValues(
status: "Error",
operationSucceeded: false,
exceptionMessage: e.Message,
customMessage: "Greška kod dohvata zapisa o trošku za zadanu kategoriju troška [Expense->getAllByExpenseType]",
helpLink: e.HelpLink,
errorCode: e.ErrorCode,
stackTrace: e.StackTrace);
throw new DataAccessException(e.Message, e.InnerException, dataAccessResult);
}
}
return(list);
}
public void Create(IUserModel userModel)
{
DataAccessResult dataAccessResult = new DataAccessResult();
string sql = "INSERT INTO User (FirstName, LastName, CarModel) VALUES (@FirstName, @LastName, @CarModel)";
using (SQLiteConnection connection = new SQLiteConnection(_connectionString))
{
try
{
connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(sql, connection))
{
try
{
RecordExistsCheck(cmd, userModel);
}
catch (DataAccessException ex)
{
ex.DataAccessResult.CustomMessage = "Korisnik već postoji u bazi podataka";
ex.DataAccessResult.ExceptionMessage = string.Copy(ex.Message);
ex.DataAccessResult.StackTrace = string.Copy(ex.StackTrace);
throw ex;
}
cmd.CommandText = sql;
cmd.Prepare();
cmd.Parameters.AddWithValue("@FirstName", userModel.FirstName);
cmd.Parameters.AddWithValue("@LastName", userModel.LastName);
cmd.Parameters.AddWithValue("@CarModel", userModel.CarModel);
cmd.ExecuteNonQuery();
}
}
catch (SQLiteException e)
{
dataAccessResult.setValues(
status: "Error",
operationSucceeded: false,
exceptionMessage: e.Message,
customMessage: "Greška kod kreiranja novog korisnika [User->Create]",
helpLink: e.HelpLink,
errorCode: e.ErrorCode,
stackTrace: e.StackTrace);
throw new DataAccessException(e.Message, e.InnerException, dataAccessResult);
}
}
return;
}
public void Update(IExpenseTypeModel expenseTypeModel)
{
DataAccessResult dataAccessResult = new DataAccessResult();
string sql = "UPDATE ExpenseType SET ExpenseTypeName = @ExpenseTypeName WHERE ExpenseType.ExpenseTypeId = @ExpenseTypeId;";
using (SQLiteConnection connection = new SQLiteConnection(_connectionString))
{
try
{
connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(sql, connection))
{
try
{
RecordExistsCheck(cmd, expenseTypeModel);
}
catch (DataAccessException ex)
{
ex.DataAccessResult.CustomMessage = "Kategorija troška već postoji u bazi podataka";
ex.DataAccessResult.ExceptionMessage = string.Copy(ex.Message);
ex.DataAccessResult.StackTrace = string.Copy(ex.StackTrace);
throw ex;
}
cmd.CommandText = sql;
cmd.Prepare();
cmd.Parameters.Add(new SQLiteParameter("@ExpenseTypeId", expenseTypeModel.ExpenseTypeId));
cmd.Parameters.Add(new SQLiteParameter("@ExpenseTypeName", expenseTypeModel.ExpenseTypeName));
cmd.ExecuteNonQuery();
}
}
catch (SQLiteException e)
{
dataAccessResult.setValues(
status: "Error",
operationSucceeded: false,
exceptionMessage: e.Message,
customMessage: "Greška kod ažuriranja zapisa kategorije troška [ExpenseType->Update]",
helpLink: e.HelpLink,
errorCode: e.ErrorCode,
stackTrace: e.StackTrace);
throw new DataAccessException(e.Message, e.InnerException, dataAccessResult);
}
}
return;
}
private void _parse()
{
_dataResultType = m_io.ReadU1();
switch (DataResultType)
{
case 0: {
_dataResultValue = new DlmsData(m_io);
break;
}
case 1: {
_dataResultValue = new DataAccessResult(m_io, this, m_root);
break;
}
}
}
public async Task <IActionResult> RunGet(
[HttpTrigger(AuthorizationLevel.Function, "get", Route = "preferences")] HttpRequest req,
[UserIdentity] string?username,
ILogger log)
{
if (username == null)
{
return(new UnauthorizedResult());
}
DataAccessResult <UserPreferences> result = await dataService.GetUserPreferences(username);
if (result.Success)
{
return(new OkObjectResult(new BackendResult <UserPreferences>(result.Resource)));
}
else if (result.StatusCode == 404)
{
DataAccessResult <StudentCredential> fetchUserResult = await dataService.GetCredentialAsync(username);
if (fetchUserResult.Success)
{
UserPreferences preferences = new UserPreferences(username);
DataAccessResult createPreferencesResult = await dataService.SetUserPreferences(preferences);
if (!createPreferencesResult.Success)
{
log.LogWarning("Failed to create preference record in database. Username: {username}, Status {statusCode}", username, createPreferencesResult.StatusCode);
}
return(new OkObjectResult(new BackendResult <UserPreferences>(preferences)));
}
else if (fetchUserResult.StatusCode == 404)
{
return(new UnauthorizedResult());
}
else
{
log.LogError("Failed to fetch user credentials from database. Username: {username}, Status {statusCode}", username, result.StatusCode);
return(GetFailedResult(false));
}
}
else
{
log.LogError("Failed to fetch user preferences from database. Username: {username}, Status {statusCode}", username, result.StatusCode);
return(GetFailedResult(false));
}
}
private void _parse()
{
_lastBlock = m_io.ReadU1();
_blockNumber = m_io.ReadU4be();
_resultChoice = m_io.ReadU1();
switch (ResultChoice)
{
case 0: {
_result = new DlmsData.OctetString(m_io);
break;
}
case 1: {
_result = new DataAccessResult(m_io, this, m_root);
break;
}
}
}
private async Task <string?> GetTokenAsync(ILogger log)
{
DataAccessResult <PushAccessToken> result = await dataService.GetPushAccessTokenAsync(Platform);
if (result.Success)
{
return(result.Resource.Token);
}
else if (result.StatusCode == 404)
{
return(await RenewTokenAsync(log));
}
else
{
log.LogWarning("Unable to fetch WNS token from database. Status code: {statusCode}", result.StatusCode);
return(null);
}
}
public virtual DataAccessResult <TEntity> Get(TPK byId)
{
var result = new DataAccessResult <TEntity>();
try
{
result.Data = GetEntity(byId);
result.IsSuccessful = true;
}
catch (Exception ex)
{
result.IsSuccessful = false;
result.Error = ErrorValues.GENERIC_FATAL_BACKEND_ERROR;
Logger.Error(GetFormattedGenericLogMessage(GENERIC_GET_LOG_MESSAGE), ex);
}
return(result);
}
public async Task <DataAccessResult <StudentCredential> > GetCredentialAsync(string username)
{
DataAccessResult <StudentCredential> fetchResult = await GetResourceAsync <StudentCredential>($"Credential-{username}", "Credential");
if (fetchResult.Success)
{
try
{
encryptionService.DecryptCredential(fetchResult.Resource);
}
catch (System.Security.Cryptography.CryptographicException)
{
// Key changed after last encryption. Equivalent to credential loss.
return(new DataAccessResult <StudentCredential>(false, null, 404));
}
}
return(fetchResult);
}
public IExpenseTypeModel GetById(int Id)
{
DataAccessResult dataAccessResult = new DataAccessResult();
ExpenseTypeModel expenseModel = new ExpenseTypeModel();
string sql = "SELECT * FROM ExpenseType WHERE ExpenseType.ExpenseTypeId = @ExpenseTypeId";
using (SQLiteConnection connection = new SQLiteConnection(_connectionString))
{
try
{
connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(sql, connection))
{
cmd.CommandText = sql;
cmd.Prepare();
cmd.Parameters.Add(new SQLiteParameter("@ExpenseTypeId", Id));
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
expenseModel.ExpenseTypeId = Int32.Parse(reader["ExpenseTypeId"].ToString());
expenseModel.ExpenseTypeName = reader["ExpenseTypeName"].ToString();
}
}
}
}
catch (SQLiteException e)
{
dataAccessResult.setValues(
status: "Error",
operationSucceeded: false,
exceptionMessage: e.Message,
customMessage: "Greška kod dohvata zapisa o trošku [ExpenseType->GetById]",
helpLink: e.HelpLink,
errorCode: e.ErrorCode,
stackTrace: e.StackTrace);
throw new DataAccessException(e.Message, e.InnerException, dataAccessResult);
}
}
return(expenseModel);
}
public List <int> GetDistinctYears(int UserId)
{
List <int> list = new List <int>();
DataAccessResult dataAccessResult = new DataAccessResult();
string sql = "SELECT DISTINCT(strftime('%Y', Date)) as Year from Expense WHERE UserId = @UserId";
using (SQLiteConnection connection = new SQLiteConnection(_connectionString))
{
try
{
connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(sql, connection))
{
cmd.CommandText = sql;
cmd.Prepare();
cmd.Parameters.Add(new SQLiteParameter("@UserId", UserId));
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
list.Add(Int32.Parse(reader["Year"].ToString()));
}
}
}
}
catch (SQLiteException e)
{
dataAccessResult.setValues(
status: "Error",
operationSucceeded: false,
exceptionMessage: e.Message,
customMessage: "Greška kod dohvata liste godina potrošnje [Expense->GetDistinctYears]",
helpLink: e.HelpLink,
errorCode: e.ErrorCode,
stackTrace: e.StackTrace);
throw new DataAccessException(e.Message, e.InnerException, dataAccessResult);
}
}
return(list);
}
public async Task <List <string>?> GetUsersAsync(ILogger log)
{
try
{
DataAccessResult <List <string> > userFetchResult = await dataService.GetUsersAsync();
return(userFetchResult.Resource);
}
catch (Azure.Cosmos.CosmosException ex)
{
log.LogError(ex, "Cannot fetch user credentials. Status {statusCode}", ex.Status);
return(null);
}
catch (Exception ex)
{
log.LogError(ex, "Cannot fetch user credentials.");
return(null);
}
}
protected DataAccessResult <T> ExecuteAdataAccess <T>(Func <DataAccessResult <T>, T> func, T defaultValue = default(T))
{
var response = new DataAccessResult <T>();
var result = defaultValue;
try
{
result = func(response);
response.Value = result;
}
catch (Exception ex)
{
response.Error = ex;
response.Value = defaultValue;
SkExceptionHandler.HandleDataAccessException(ex);
}
return(response);
}
public IEnumerable <IExpenseTypeModel> GetAll()
{
DataAccessResult dataAccessResult = new DataAccessResult();
List <ExpenseTypeModel> list = new List <ExpenseTypeModel>();
string sql = "SELECT * FROM ExpenseType";
using (SQLiteConnection connection = new SQLiteConnection(_connectionString))
{
try
{
connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(sql, connection))
{
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
ExpenseTypeModel expenseTypeModel = new ExpenseTypeModel();
expenseTypeModel.ExpenseTypeId = Int32.Parse(reader["ExpenseTypeId"].ToString());
expenseTypeModel.ExpenseTypeName = reader["ExpenseTypeName"].ToString();
list.Add(expenseTypeModel);
}
}
}
}
catch (SQLiteException e)
{
dataAccessResult.setValues(
status: "Error",
operationSucceeded: false,
exceptionMessage: e.Message,
customMessage: "Greška kod dohvata svih zapisa kategorije troška [ExpenseType->GetAll]",
helpLink: e.HelpLink,
errorCode: e.ErrorCode,
stackTrace: e.StackTrace);
throw new DataAccessException(e.Message, e.InnerException, dataAccessResult);
}
}
return(list);
}
/// <summary>
/// Saves a file attachment for an application.
/// </summary>
/// <param name="applicationId">The application id.</param>
/// <param name="controlName">The name of the file upload control.</param>
/// <param name="fileIdentifier">The file identifier.</param>
/// <param name="data">The file to save as a byte array.</param>
/// <returns>A <see cref="DataAccessResult"/>.</returns>
protected override DataAccessResult DoSaveAttachment(string applicationId, string controlName, string fileIdentifier, byte[] data)
{
var attachmentCollection = this.database.GetCollection(iApplyDb.ApplicationAttachments._COLLECTION_NAME);
BsonValue bsonApplicationId = new BsonString(applicationId);
BsonValue bsonControlName = new BsonString(controlName);
BsonValue bsonFileIdentifier = new BsonString(fileIdentifier);
var query = Query.And(
Query.EQ(iApplyDb.ApplicationAttachments.APPLICATION_ID, bsonApplicationId),
Query.EQ(iApplyDb.ApplicationAttachments.CONTROL_NAME, bsonControlName));
BsonDocument document = attachmentCollection.FindOne(query) ?? new BsonDocument
{
{ iApplyDb.ApplicationAttachments.APPLICATION_ID, bsonApplicationId },
{ iApplyDb.ApplicationAttachments.CONTROL_NAME, bsonControlName },
{ iApplyDb.ApplicationAttachments.FILES, new BsonArray() }
};
BsonArray array = document.GetValue(iApplyDb.ApplicationAttachments.FILES).AsBsonArray;
BsonValue fileDocument = array.FirstOrDefault(d => ((BsonDocument)d).GetValue(iApplyDb.ApplicationAttachments.Files.FILE_IDENTIFIER).AsString == fileIdentifier);
if (fileDocument == null)
{
fileDocument = new BsonDocument();
fileDocument.AsBsonDocument.Add(iApplyDb.ApplicationAttachments.Files.FILE_IDENTIFIER, bsonFileIdentifier);
array.Add(fileDocument);
}
fileDocument.AsBsonDocument[iApplyDb.ApplicationAttachments.Files.FILE] = new BsonBinaryData(data);
attachmentCollection.Save(document);
DataAccessResult result = new DataAccessResult
{
ApplicationId = applicationId,
Id = document[iApplyDb.ApplicationAttachments._ID].AsObjectId.ToString()
};
return result;
}
/// <summary>
/// Saves a payment response, associated to an application.
/// </summary>
/// <param name="applicationId">The application id.</param>
/// <param name="response">The response from the payment provider.</param>
/// <returns>A <see cref="DataAccessResult"/>.</returns>
protected override DataAccessResult DoSavePaymentResponse(string applicationId, TransactionResponse response)
{
var applicationCollection = this.database.GetCollection("applicationPayments");
BsonValue bsonApplicationId = new BsonString(applicationId);
BsonDocument bsonResponse = this.TransactionResponseToBsonDocument(response);
IMongoQuery query = Query.EQ("applicationId", bsonApplicationId);
BsonDocument document = applicationCollection.FindOne(query) ?? new BsonDocument
{
{ "applicationId", bsonApplicationId },
{ "payments", new BsonArray() }
};
BsonArray array = document.GetValue("payments").AsBsonArray;
array.Add(bsonResponse);
applicationCollection.Save(document);
DataAccessResult result = new DataAccessResult
{
ApplicationId = applicationId,
Id = document["_id"].AsObjectId.ToString()
};
return result;
}
