public async Task <OperationDataResult <CustomerSettingsModel> > GetSettings()
{
try
{
var result = new CustomerSettingsModel();
var customerSettings = _options.Value;
if (customerSettings?.RelatedEntityGroupId != null)
{
result.RelatedEntityId = (int)customerSettings.RelatedEntityGroupId;
var core = _coreHelper.GetCore();
var entityGroup = await core.Result.EntityGroupRead(customerSettings.RelatedEntityGroupId.ToString());
if (entityGroup == null)
{
return(new OperationDataResult <CustomerSettingsModel>(false, "Entity group not found"));
}
result.RelatedEntityName = entityGroup.Name;
}
return(new OperationDataResult <CustomerSettingsModel>(true, result));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <CustomerSettingsModel>(false,
_customersLocalizationService.GetString("ErrorObtainingCustomersInfo")));
}
}
public async Task <OperationDataResult <List <UnitModel> > > Index()
{
var core = await _coreHelper.GetCore();
await using var dbContext = core.DbContextHelper.GetDbContext();
var units = await dbContext.Units.AsNoTracking().Select(t => new UnitModel()
{
Id = t.Id,
CreatedAt = t.CreatedAt,
UpdatedAt = t.UpdatedAt,
CustomerNo = t.CustomerNo,
OtpCode = t.OtpCode,
SiteId = (int)t.SiteId,
SiteMicrotingUid = (int)t.Site.MicrotingUid,
SiteName = t.Site.Name,
Model = t.Model,
Manufacturer = t.Manufacturer,
Note = t.Note,
Os = "",
OsVersion = t.OsVersion,
MicrotingUid = (int)t.MicrotingUid,
eFormVersion = "0.0.0",
InSightVersion = "0.0.0",
eFormVersionHealth = "",
InSightVersionHealth = "",
PushEnabled = t.PushEnabled,
SyncDialog = t.SyncDialog,
SyncDefaultDelay = t.SyncDefaultDelay,
SyncDelayEnabled = t.SyncDelayEnabled,
SyncDelayPrCheckList = t.SyncDelayPrCheckList
}).ToListAsync().ConfigureAwait(false);
return(new OperationDataResult <List <UnitModel> >(true, units));
}
public async Task <OperationDataResult <List <CommonDictionaryModel> > > GetSurveys()
{
try
{
var core = await _coreHelper.GetCore();
using (var sdkContext = core.DbContextHelper.GetDbContext())
{
var surveys = await sdkContext.QuestionSets
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Select(x => new CommonDictionaryModel()
{
Id = x.Id,
Name = x.Name,
}).ToListAsync();
return(new OperationDataResult <List <CommonDictionaryModel> >(true, surveys));
}
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <List <CommonDictionaryModel> >(false,
_localizationService.GetString("ErrorWhileObtainingSurveys")));
}
}
public async Task <OperationDataResult <List <CommonDictionaryModel> > > GetSitesDictionary()
{
try
{
var core = await _coreHelper.GetCore();
await using var dbContext = core.DbContextHelper.GetDbContext();
var sites = await dbContext.Sites
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Select(x => new CommonDictionaryModel
{
Id = x.Id,
Name = x.Name,
})
.OrderBy(x => x.Name)
.ToListAsync();
return(new OperationDataResult <List <CommonDictionaryModel> >(true, sites));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(new OperationDataResult <List <CommonDictionaryModel> >(false,
_localizationService.GetString("ErrorWhileObtainingSites")));
}
}
public async Task <OperationDataResult <List <CommonDictionaryModel> > > Index()
{
try
{
var core = await _coreHelper.GetCore();
var tags = await core.GetAllTags(false);
var model = new List <CommonDictionaryModel>(tags.Count);
tags.ForEach(tag =>
{
model.Add(new CommonDictionaryModel()
{
Id = tag.Id,
Name = tag.Name,
});
});
return(new OperationDataResult <List <CommonDictionaryModel> >(true, model));
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(new OperationDataResult <List <CommonDictionaryModel> >(false,
_localizationService.GetString("ErrorWhileObtainTags")));
}
}
public async Task <OperationDataResult <List <WorkerDto> > > Index()
{
var core = await _coreHelper.GetCore();
var workersDto = await core.Advanced_WorkerReadAll("not_removed", null, null);
return(new OperationDataResult <List <WorkerDto> >(true, workersDto));
}
public async Task <OperationResult> Create(ItemsListPnModel model)
{
try
{
var core = await _coreHelper.GetCore();
await using var dbContext = core.DbContextHelper.GetDbContext();
var locale = await _userService.GetCurrentUserLocale();
var language = dbContext.Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
var template = await core.TemplateItemRead(model.RelatedEFormId, language);
var itemsList = new ItemList
{
Name = model.Name,
Description = model.Description,
CreatedByUserId = _userService.UserId,
RepeatEvery = model.RepeatEvery,
RepeatUntil = model.RepeatUntil,
RepeatType = model.RepeatType,
DayOfWeek = model.DayOfWeek,
DayOfMonth = model.DayOfMonth,
Enabled = true,
RelatedEFormId = model.RelatedEFormId,
RelatedEFormName = template?.Label
};
await itemsList.Create(_dbContext);
foreach (var item in model.Items.Select(itemModel => new Item()
{
LocationCode = itemModel.LocationCode,
ItemNumber = itemModel.ItemNumber,
Description = itemModel.Description,
Name = itemModel.Name,
Enabled = true,
BuildYear = itemModel.BuildYear,
Type = itemModel.Type,
ItemListId = itemsList.Id,
CreatedByUserId = _userService.UserId,
}))
{
await item.Create(_dbContext);
}
return(new OperationResult(
true,
_itemsPlanningLocalizationService.GetString("ListCreatedSuccessfully")));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationResult(false,
_itemsPlanningLocalizationService.GetString("ErrorWhileCreatingList")));
}
}
public async Task <OperationDataResult <TemplateListModel> > GetAvailableEforms(
TemplateRequestModel templateRequestModel,
int groupId)
{
try
{
TimeZoneInfo timeZoneInfo = await _userService.GetCurrentUserTimeZoneInfo();
var result = new TemplateListModel
{
Templates = new List <TemplateDto>()
};
var core = await _coreHelper.GetCore();
var locale = await _userService.GetCurrentUserLocale();
Language language = core.DbContextHelper.GetDbContext().Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
var templatesDto = await core.TemplateItemReadAll(false,
"",
templateRequestModel.NameFilter,
templateRequestModel.IsSortDsc,
templateRequestModel.Sort,
templateRequestModel.TagIds, timeZoneInfo, language).ConfigureAwait(false);
var eformsInGroup = await _dbContext.EformInGroups
.Where(x => x.SecurityGroupId == groupId)
.Select(x => x.TemplateId)
.ToListAsync();
if (templatesDto.Any())
{
foreach (var templateDto in templatesDto)
{
if (!eformsInGroup.Contains(templateDto.Id))
{
result.Templates.Add(templateDto);
}
}
result.NumOfElements = templatesDto.Count;
result.PageNum = 1;
}
return(new OperationDataResult <TemplateListModel>(true, result));
}
catch (Exception e)
{
Console.WriteLine(e);
_logger.LogError(e.Message);
return(new OperationDataResult <TemplateListModel>(false,
_localizationService.GetString("ErrorWhileObtainingAvailableEForms")));
}
}
public async Task <IActionResult> GetImage(string fileName)
{
var filePath = PathHelper.GetEformSettingsImagesPath(fileName);
string ext = Path.GetExtension(fileName).Replace(".", "");
if (ext == "jpg")
{
ext = "jpeg";
}
string fileType = $"image/{ext}";
var core = await _coreHelper.GetCore();
if (core.GetSdkSetting(Settings.swiftEnabled).Result.ToLower() == "true")
{
var ss = await core.GetFileFromSwiftStorage(fileName);
if (ss == null)
{
return(NotFound($"Trying to find file at location: {filePath}"));
}
Response.ContentType = ss.ContentType;
Response.ContentLength = ss.ContentLength;
return(File(ss.ObjectStreamContent, ss.ContentType.IfNullOrEmpty(fileType), fileName));
// return File(ss.ObjectStreamContent, ss.ContentType.IfNullOrEmpty("application/octet-stream"), fileName);
}
if (core.GetSdkSetting(Settings.s3Enabled).Result.ToLower() == "true")
{
var ss = await core.GetFileFromS3Storage($"{fileName}");
Response.ContentLength = ss.ContentLength;
return(File(ss.ResponseStream, ss.Headers["Content-Type"]));
}
if (!System.IO.File.Exists(filePath))
{
return(NotFound($"Trying to find file at location: {filePath}"));
}
var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
return(File(fileStream, fileType));
}
public async Task <OperationDataResult <ReportModel> > GenerateReport(GenerateReportModel model)
{
try
{
var core = await _coreHelper.GetCore();
await using var dbContext = core.DbContextHelper.GetDbContext();
var itemList = await _dbContext.ItemLists.FirstAsync(x => x.Id == model.ItemList);
var item = await _dbContext.Items.FirstAsync(x => x.Id == model.Item);
var locale = await _userService.GetCurrentUserLocale();
Language language = dbContext.Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
var template = await core.ReadeForm(itemList.RelatedEFormId, language);
var casesQuery = _dbContext.ItemCases.Where(x => x.ItemId == item.Id);
if (model.DateFrom != null)
{
casesQuery = casesQuery.Where(x =>
x.CreatedAt >= new DateTime(model.DateFrom.Value.Year, model.DateFrom.Value.Month, model.DateFrom.Value.Day, 0, 0, 0));
}
if (model.DateTo != null)
{
casesQuery = casesQuery.Where(x =>
x.CreatedAt <= new DateTime(model.DateTo.Value.Year, model.DateTo.Value.Month, model.DateTo.Value.Day, 23, 59, 59));
}
var itemCases = await casesQuery.ToListAsync();
var reportModel = await GetReportData(model, item, itemCases, template);
return(new OperationDataResult <ReportModel>(true, reportModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <ReportModel>(false,
_itemsPlanningLocalizationService.GetString("ErrorWhileGeneratingReport")));
}
}
public async Task <OperationDataResult <List <FolderDtoModel> > > List()
{
try
{
var core = await _coreHelper.GetCore();
await using var dbContext = core.DbContextHelper.GetDbContext();
var locale = await _userService.GetCurrentUserLocale();
var language = dbContext.Languages.Single(x => x.LanguageCode == locale);
var folderQuery = dbContext.Folders
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.FolderTranslations.Any(y =>
y.LanguageId == language.Id && !string.IsNullOrEmpty(y.Name)));
var folders = await AddSelectToQueryForList(folderQuery, language.Id)
.OrderBy(x => x.Name)
.ToListAsync();
return(new OperationDataResult <List <FolderDtoModel> >(true, folders));
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(new OperationDataResult <List <FolderDtoModel> >(
false,
_localizationService.GetString("ErrorWhileObtainingFoldersInfo")));
}
}
public async Task <OperationDataResult <SegmentsModel> > Index(SegmentRequestModel pnRequestModel)
{
try
{
SegmentsModel segmentsModel = new SegmentsModel();
IQueryable <Segment> segmentQuery = _dbContext.Segments.AsQueryable();
if (!string.IsNullOrEmpty(pnRequestModel.Sort))
{
if (pnRequestModel.IsSortDsc)
{
segmentQuery = segmentQuery
.CustomOrderByDescending(pnRequestModel.Sort);
}
else
{
segmentQuery = segmentQuery
.CustomOrderBy(pnRequestModel.Sort);
}
}
else
{
segmentQuery = _dbContext.Segments
.OrderBy(x => x.Id);
}
segmentQuery
= segmentQuery
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
List <SegmentModel> segmentModels = await segmentQuery.Select(x => new SegmentModel
{
Id = x.Id,
Name = x.Name,
Description = x.Description,
SdkFolderId = x.SdkFolderId
}).ToListAsync();
segmentsModel.Total = await _dbContext.Segments.CountAsync(x => x.WorkflowState != Constants.WorkflowStates.Removed);
segmentsModel.SegmentList = segmentModels;
Core _core = await _coreHelper.GetCore();
return(new OperationDataResult <SegmentsModel>(true, segmentsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_coreHelper.LogException(e.Message);
return(new OperationDataResult <SegmentsModel>(false,
_trashInspectionLocalizationService.GetString("ErrorObtainingSegments")));
}
}
public async Task <OperationDataResult <CaseListModel> > Index(CaseRequestModel requestModel)
{
try
{
var value = _httpContextAccessor?.HttpContext.User?.FindFirstValue(ClaimTypes.NameIdentifier);
var timeZone = _dbContext.Users.Single(x => x.Id == int.Parse(value)).TimeZone;
if (string.IsNullOrEmpty(timeZone))
{
timeZone = "Europe/Copenhagen";
}
TimeZoneInfo timeZoneInfo;
try
{
timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(timeZone);
}
catch
{
timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById("E. Europe Standard Time");
}
var core = await _coreHelper.GetCore();
var caseList = await core.CaseReadAll(requestModel.TemplateId, null, null,
Constants.WorkflowStates.NotRemoved, requestModel.NameFilter,
requestModel.IsSortDsc, requestModel.Sort, requestModel.Offset, requestModel.PageSize, timeZoneInfo);
var model = new CaseListModel()
{
NumOfElements = caseList.NumOfElements,
PageNum = caseList.PageNum,
Cases = caseList.Cases
};
return(new OperationDataResult <CaseListModel>(true, model));
}
catch (Exception ex)
{
Log.LogException(ex.Message);
Log.LogException(ex.StackTrace);
return(new OperationDataResult <CaseListModel>(false, _localizationService.GetString("CaseLoadingFailed") + $" Exception: {ex.Message}"));
}
}
public async Task <OperationResult> IntegrityCheck()
{
Core core = await _coreHelper.GetCore();
MicrotingDbContext dbContext = core.DbContextHelper.GetDbContext();
_logger.LogInformation("Checking uploaded data");
var uploadedDatas =
await dbContext.UploadedDatas.Where(x => x.FileLocation.Contains("https://")).ToListAsync();
_logger.LogInformation($"Found {uploadedDatas.Count} uploaded data items, which needs download");
foreach (UploadedData uploadedData in uploadedDatas)
{
_logger.LogInformation($"Trying to download from {uploadedData.FileLocation}");
await core.DownloadUploadedData(uploadedData.Id);
}
return(new OperationResult(true));
}
public async Task <OperationResult> UploadUploadedData(UploadedDataModel uploadModel)
{
try
{
var core = await _coreService.GetCore();
Directory.CreateDirectory(SaveFolder);
foreach (var file in uploadModel.Files)
{
// get the file extension. we separate the file name with a separator (dot) and get the last element of the resulting array
var typeFile = file.FileName.Split('.')[^ 1];
public async Task <IActionResult> UploadUploadedDataPdf(UploadedDataPDFUploadModel pdfUploadModel)
{
try
{
var core = _core.GetCore();
var saveFolder = Path.Combine(await core.Result.GetSdkSetting(Settings.fileLocationPdf), Path.Combine("pdfFiles"));
Directory.CreateDirectory(saveFolder);
string fileName = $"ItemCase_{pdfUploadModel.ItemCaseId}_{DateTime.Now.Ticks}.pdf";
if (pdfUploadModel.File.Length > 0)
{
using (var stream = new FileStream(Path.Combine(saveFolder, fileName), FileMode.Create))
{
await pdfUploadModel.File.CopyToAsync(stream);
}
}
if (core.Result.GetSdkSetting(Settings.swiftEnabled).ToString().ToLower() == "true")
{
await core.Result.PutFileToStorageSystem(Path.Combine(saveFolder, fileName), fileName);
}
UploadedData uploadedData = new UploadedData();
uploadedData.FileLocation = saveFolder;
uploadedData.FileName = fileName;
uploadedData.ItemCaseId = pdfUploadModel.ItemCaseId;
await uploadedData.Create(_dbContext);
return(new OkResult());
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_core.LogException(e.Message);
return(new BadRequestResult());
}
}
public async Task <OperationDataResult <InventorySettingsModel> > GetSettings()
{
var sdkCore =
await _coreService.GetCore();
await using var sdkDbContext = sdkCore.DbContextHelper.GetDbContext();
try
{
var option = _options.Value;
var siteIds = _dbContext.AssignedSites
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Select(site => site.SiteUid)
.ToList();
var assignetSites = sdkDbContext.Sites
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => siteIds.Contains((int)x.MicrotingUid))
.Select(x => new SiteNameDto((int)x.MicrotingUid, x.Name, x.CreatedAt, x.UpdatedAt))
.ToList();
var settings = new InventorySettingsModel
{
AssignedSites = assignetSites,
FolderId = option.FolderId,
};
return(new OperationDataResult <InventorySettingsModel>(true, settings));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <InventorySettingsModel>(false,
_inventoryLocalizationService.GetString("ErrorWhileObtainingInventorySettings")));
}
}
public async Task <OperationDataResult <AnswerViewModel> > GetAnswerByMicrotingUid(int microtingUid)
{
try
{
var core = await _coreHelper.GetCore();
AnswerViewModel result;
await using (var sdkContext = core.DbContextHelper.GetDbContext())
{
var answersQueryable = AnswerHelper.GetAnswerQueryByMicrotingUid(microtingUid, sdkContext);
result = answersQueryable.FirstOrDefault();
}
if (result == null)
{
return(new OperationDataResult <AnswerViewModel>(
false,
_localizationService.GetString("AnswerNotFound")));
}
if (result.AnswerValues == null)
{
return(new OperationDataResult <AnswerViewModel>(
false,
_localizationService.GetString("AnswerValuesNotFound")));
}
return(new OperationDataResult <AnswerViewModel>(true, result));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <AnswerViewModel>(false,
_localizationService.GetString("ErrorWhileObtainingGetAnswer")));
}
}
public async Task <OperationDataResult <List <TemplateColumnModel> > > GetAvailableColumns(int templateId)
{
try
{
var core = await _coreHelper.GetCore();
await using MicrotingDbContext dbContext = core.DbContextHelper.GetDbContext();
var locale = await _userService.GetCurrentUserLocale();
Language language = dbContext.Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
var fields = await core.Advanced_TemplateFieldReadAll(templateId, language);
var templateColumns = new List <TemplateColumnModel>();
foreach (var field in fields)
{
if (field.FieldType != "Picture" &&
field.FieldType != "Audio" &&
field.FieldType != "Movie" &&
field.FieldType != "Signature" &&
field.FieldType != "None" &&
field.FieldType != "SaveButton")
{
templateColumns.Add(new TemplateColumnModel()
{
Id = field.Id,
Label = field.ParentName + " - " + field.Label
});
}
}
return(new OperationDataResult <List <TemplateColumnModel> >(true, templateColumns));
}
catch (Exception)
{
return(new OperationDataResult <List <TemplateColumnModel> >(false,
_localizationService.GetString("ErrorWhileObtainColumns")));
}
}
public async Task <Language> GetLanguageByUserIdAsync(int userId)
{
var core = await _coreHelper.GetCore();
var locale = await GetUserLocale(userId);
var sdkDbContext = core.DbContextHelper.GetDbContext();
var language = await sdkDbContext.Languages
.AsNoTracking()
.Where(x => x.LanguageCode.ToLower() == locale.ToLower())
.FirstAsync();
return(language);
}
public async Task Start(string connectionString)
{
_connectionString = connectionString;
_container = new WindsorContainer();
_container.Install(
new RebusHandlerInstaller()
, new RebusInstaller(connectionString, 1, 1)
);
Core _core = await _coreHelper.GetCore();
_container.Register(Component.For <Core>().Instance(_core));
_container.Register(Component.For <ItemsGroupPlanningPnDbContext>().Instance(GetContext()));
_bus = _container.Resolve <IBus>();
}
public void Start(string connectionString)
{
_connectionString = connectionString;
_container = new WindsorContainer();
_container.Install(
new RebusHandlerInstaller()
, new RebusInstaller(connectionString, 1, 1)
);
Core _core = _coreHelper.GetCore();
_container.Register(Component.For <Core>().Instance(_core));
_container.Register(Component.For <CaseTemplatePnDbContext>().Instance(GetContext()));
_bus = _container.Resolve <IBus>();
}
public async Task Start(string connectionString, string rabbitMqUser, string rabbitMqPassword, string rabbitMqHost)
{
_connectionString = connectionString;
_container = new WindsorContainer();
_container.Install(
new RebusHandlerInstaller()
, new RebusInstaller(connectionString, 1, 1, rabbitMqUser, rabbitMqPassword, rabbitMqHost)
);
Core core = await _coreHelper.GetCore();
_dbContextHelper = new DbContextHelper(connectionString);
_container.Register(Component.For <Core>().Instance(core));
_container.Register(Component.For <DbContextHelper>().Instance(_dbContextHelper));
_bus = _container.Resolve <IBus>();
}
public async Task <IActionResult> GetAudio(string fileName)
{
try
{
var core = await _coreHelper.GetCore();
if (core.GetSdkSetting(Settings.swiftEnabled).Result.ToLower() == "true")
{
var ss = await core.GetFileFromSwiftStorage($"{fileName}");
Response.ContentType = ss.ContentType;
Response.ContentLength = ss.ContentLength;
return(File(ss.ObjectStreamContent, ss.ContentType.IfNullOrEmpty("wav")));
}
if (core.GetSdkSetting(Settings.s3Enabled).Result.ToLower() == "true")
{
var ss = await core.GetFileFromS3Storage($"{fileName}");
Response.ContentLength = ss.ContentLength;
return(File(ss.ResponseStream, ss.Headers["Content-Type"]));
}
var filePath = PathHelper.GetAudioPath(fileName);
if (!System.IO.File.Exists(filePath))
{
return(NotFound());
}
var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
//result.Content = new StreamContent(stream);
//result.Content.Headers.ContentType =
// new MediaTypeHeaderValue("application/octet-stream");
//result.Content.Headers.ContentLength = stream.Length;
//result.Content.Headers.ContentRange = new ContentRangeHeaderValue(0, stream.Length);
Response.Headers.Add("Accept-Ranges", "bytes");
Response.Headers.Remove("Cache-Control");
return(File(stream, "audio/wav"));
}
catch (Exception ex)
{
return(NotFound($"Trying to find file at location: {fileName}, exception is: {ex.Message}"));
}
}
public async Task Start(string sdkConnectionString, string connectionString, int maxParallelism, int numberOfWorkers)
{
_connectionString = connectionString;
_sdkConnectionString = sdkConnectionString;
_container = new WindsorContainer();
_container.Install(
new RebusHandlerInstaller()
, new RebusInstaller(connectionString, maxParallelism, numberOfWorkers)
);
Core core = await _coreHelper.GetCore();
_dbContextHelper = new DbContextHelper(connectionString);
_container.Register(Component.For <Core>().Instance(core));
_container.Register(Component.For <DbContextHelper>().Instance(_dbContextHelper));
_bus = _container.Resolve <IBus>();
}
public async Task <IActionResult> PostLoginPageImages(IFormFile file)
{
var iUploadedCnt = 0;
var saveFolder = PathHelper.GetEformLoginPageSettingsImagesPath();
// if (string.IsNullOrEmpty(saveFolder))
// {
// return BadRequest(_localizationService.GetString("FolderError"));
// }
if (!Directory.Exists(saveFolder))
{
Directory.CreateDirectory(saveFolder);
}
if (file.Length > 0)
{
var filePath = Path.Combine(saveFolder, Path.GetFileName(file.FileName));
if (!System.IO.File.Exists(filePath))
{
using (var stream = new FileStream(filePath, FileMode.Create))
{
await file.CopyToAsync(stream);
var core = await _coreHelper.GetCore();
if (core.GetSdkSetting(Settings.swiftEnabled).Result.ToLower() == "true" || core.GetSdkSetting(Settings.s3Enabled).Result.ToLower() == "true")
{
await core.PutFileToStorageSystem(filePath, file.FileName);
}
}
iUploadedCnt++;
}
}
if (iUploadedCnt > 0)
{
return(Ok());
}
return(BadRequest("InvalidRequest"));
}
public async Task <OperationResult> ForgotPassword(ForgotPasswordModel model)
{
var core = await _coreHelper.GetCore();
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(new OperationResult(false, $"User with {model.Email} not found"));
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var link = await core.GetSdkSetting(Settings.httpServerAddress);
link = $"{link}/auth/restore-password-confirmation?userId={user.Id}&code={code}";
await _emailSender.SendEmailAsync(user.Email, "EForm Password Reset",
"Please reset your password by clicking <a href=\"" + link + "\">here</a>");
return(new OperationResult(true));
}
public async Task <OperationResult> ForgotPassword(ForgotPasswordModel model)
{
var core = await _coreHelper.GetCore();
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(new OperationResult(false, $"User with {model.Email} not found"));
}
var code = HttpUtility.UrlEncode(await _userManager.GeneratePasswordResetTokenAsync(user));
var link = await core.GetSdkSetting(Settings.httpServerAddress);
link = $"{link}/auth/restore-password-confirmation?userId={user.Id}&code={code}";
/* await _emailSender.SendEmailAsync(user.Email, "EForm Password Reset",
* "Please reset your password by clicking <a href=\"" + link + "\">here</a>");*/
var html = $"Hej {user.FirstName} {user.LastName}<br><br>" +
"Du har valgt at nulstille din adgangskode til Microting.<br>" +
"Klik på nedenstående link for at angive en ny adgangskode.<br><br>" +
$"<a href=\" {link}\">Angiv ny adgangskode</a><br><br>" +
"Hvis du ikke har anmodet om dette, så se venligst bort fra denne mail.<br><br>" +
"Din adgangskode forbliver uændret, indtil du laver en ny via linket herover.<br><br>" +
"Med venlig hilsen<br><br>" +
"Microting<br><br>" +
"Support: 66 11 10 66";
await _emailService.SendAsync(
EformEmailConst.FromEmail,
"*****@*****.**",
"Nulstilling af adgangskode",
user.Email,
html : html);
return(new OperationResult(true));
}
public async Task <OperationDataResult <Paged <EntityGroup> > > Index(
AdvEntitySelectableGroupListRequestModel requestModel)
{
try
{
var core = await _coreHelper.GetCore();
var sdkDbContext = core.DbContextHelper.GetDbContext();
var entityGroupList = new Paged <EntityGroup>();
// get query
var entitySelectableGroupQuery = sdkDbContext.EntityGroups
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.Type == Constants.FieldTypes.EntitySelect)
.AsNoTracking()
.AsQueryable();
if (!string.IsNullOrEmpty(requestModel.NameFilter))
{
entitySelectableGroupQuery = entitySelectableGroupQuery
.Where(x => x.Name.Contains(requestModel.NameFilter));
}
// sort
entitySelectableGroupQuery = QueryHelper.AddSortToQuery(entitySelectableGroupQuery, requestModel.Sort, requestModel.IsSortDsc);
// count elements
entityGroupList.Total = await entitySelectableGroupQuery.Select(x => x.Id).CountAsync();
// pagination
entitySelectableGroupQuery =
entitySelectableGroupQuery
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
// select and take from db
var entityGroups = await entitySelectableGroupQuery
.Select(x => new EntityGroup
{
Description = x.Description,
WorkflowState = x.WorkflowState,
CreatedAt = x.CreatedAt,
Id = x.Id,
MicrotingUUID = x.MicrotingUid,
Name = x.Name,
Type = x.Type,
UpdatedAt = x.UpdatedAt,
EntityGroupItemLst = new List <EntityItem>(),
}).ToListAsync();
entityGroupList.Entities = entityGroups;
var plugins = await _dbContext.EformPlugins.Select(x => x.PluginId).ToListAsync();
foreach (var entityGroup in entityGroupList.Entities)
{
foreach (var _ in plugins.Where(plugin => entityGroup.Name.Contains(plugin)))
{
entityGroup.IsLocked = true;
}
}
return(new OperationDataResult <Paged <EntityGroup> >(true, entityGroupList));
}
catch (Exception)
{
return(new OperationDataResult <Paged <EntityGroup> >(false,
_localizationService.GetString("SelectableGroupLoadingFailed")));
}
}
private async Task <ItemListPnCaseResultListModel> GetTableData(ItemListCasesPnRequestModel requestModel)
{
var pluginConfigurationValue = _options.Value.Token;
var itemList = await _dbContext.ItemLists
.SingleOrDefaultAsync(x => x.Id == requestModel.ListId);
var core = await _core.GetCore();
await using var microtingDbContext = core.DbContextHelper.GetDbContext();
var locale = await _userService.GetCurrentUserLocale();
var language = microtingDbContext.Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
var allFields = await core.Advanced_TemplateFieldReadAll(itemList.RelatedEFormId, language);
// filter fields
allFields = allFields.Where(x => x.FieldType != Constants.FieldTypes.SaveButton).ToList();
var itemListPnCaseResultListModel = new ItemListPnCaseResultListModel
{
LabelEnabled = itemList.LabelEnabled,
DescriptionEnabled = itemList.DescriptionEnabled,
DeployedAtEnabled = itemList.DeployedAtEnabled,
DoneAtEnabled = itemList.DoneAtEnabled,
DoneByUserNameEnabled = itemList.DoneByUserNameEnabled,
UploadedDataEnabled = itemList.UploadedDataEnabled,
ItemNumberEnabled = itemList.ItemNumberEnabled,
LocationCodeEnabled = itemList.LocationCodeEnabled,
BuildYearEnabled = itemList.BuildYearEnabled,
TypeEnabled = itemList.TypeEnabled,
NumberOfImagesEnabled = itemList.NumberOfImagesEnabled,
SdkeFormId = itemList.RelatedEFormId,
FieldEnabled1 = itemList.SdkFieldEnabled1,
FieldEnabled2 = itemList.SdkFieldEnabled2,
FieldEnabled3 = itemList.SdkFieldEnabled3,
FieldEnabled4 = itemList.SdkFieldEnabled4,
FieldEnabled5 = itemList.SdkFieldEnabled5,
FieldEnabled6 = itemList.SdkFieldEnabled6,
FieldEnabled7 = itemList.SdkFieldEnabled7,
FieldEnabled8 = itemList.SdkFieldEnabled8,
FieldEnabled9 = itemList.SdkFieldEnabled9,
FieldEnabled10 = itemList.SdkFieldEnabled10,
FieldName1 = itemList.SdkFieldEnabled1 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId1)?.Label : "",
FieldName2 = itemList.SdkFieldEnabled2 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId2)?.Label : "",
FieldName3 = itemList.SdkFieldEnabled3 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId3)?.Label : "",
FieldName4 = itemList.SdkFieldEnabled4 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId4)?.Label : "",
FieldName5 = itemList.SdkFieldEnabled5 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId5)?.Label : "",
FieldName6 = itemList.SdkFieldEnabled6 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId6)?.Label : "",
FieldName7 = itemList.SdkFieldEnabled7 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId7)?.Label : "",
FieldName8 = itemList.SdkFieldEnabled8 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId8)?.Label : "",
FieldName9 = itemList.SdkFieldEnabled9 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId9)?.Label : "",
FieldName10 = itemList.SdkFieldEnabled10 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId10)?.Label : "",
};
var newItems = _dbContext.Items
.Where(item => item.ItemListId == requestModel.ListId)
.Join(_dbContext.ItemCases, item => item.Id, itemCase => itemCase.ItemId,
(item, itemCase) => new
{
itemCase.Id,
item.Name,
item.Description,
item.BuildYear,
item.LocationCode,
item.ItemNumber,
item.Type,
itemCase.MicrotingSdkCaseDoneAt,
itemCase.MicrotingSdkCaseId,
itemCase.Status,
itemCase.CreatedAt,
itemCase.DoneByUserName,
itemCase.SdkFieldValue1,
itemCase.SdkFieldValue2,
itemCase.SdkFieldValue3,
itemCase.SdkFieldValue4,
itemCase.SdkFieldValue5,
itemCase.SdkFieldValue6,
itemCase.SdkFieldValue7,
itemCase.SdkFieldValue8,
itemCase.SdkFieldValue9,
itemCase.SdkFieldValue10,
itemCase.WorkflowState,
itemCase.NumberOfImages
});
if (requestModel.DateFrom != null)
{
newItems = newItems.Where(x =>
x.CreatedAt >= new DateTime(requestModel.DateFrom.Value.Year, requestModel.DateFrom.Value.Month, requestModel.DateFrom.Value.Day, 0, 0, 0));
}
if (requestModel.DateTo != null)
{
newItems = newItems.Where(x =>
x.CreatedAt <= new DateTime(requestModel.DateTo.Value.Year, requestModel.DateTo.Value.Month, requestModel.DateTo.Value.Day, 23, 59, 59));
}
// Add sort
newItems = QueryHelper.AddSortToQuery(newItems, requestModel.Sort, requestModel.IsSortDsc);
newItems = newItems
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed);
// Get total
itemListPnCaseResultListModel.Total = await newItems.Select(x => x.Id).CountAsync();
// Pagination
newItems
= newItems
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
// add select and get from db
itemListPnCaseResultListModel.Items = newItems
.Select(x => new ItemsListPnCaseResultModel
{
Id = x.Id,
DoneAt = x.MicrotingSdkCaseDoneAt,
DeployedAt = x.CreatedAt,
DoneByUserName = x.DoneByUserName,
Label = x.Name,
Description = x.Description,
ItemNumber = x.ItemNumber,
LocationCode = x.LocationCode,
BuildYear = x.BuildYear,
Type = x.Type,
NumberOfImages = x.NumberOfImages,
Field1 = x.SdkFieldValue1,
Field2 = x.SdkFieldValue2,
Field3 = x.SdkFieldValue3,
Field4 = x.SdkFieldValue4,
Field5 = x.SdkFieldValue5,
Field6 = x.SdkFieldValue6,
Field7 = x.SdkFieldValue7,
Field8 = x.SdkFieldValue8,
Field9 = x.SdkFieldValue9,
Field10 = x.SdkFieldValue10,
SdkCaseId = x.MicrotingSdkCaseId,
SdkeFormId = itemList.RelatedEFormId,
Status = x.Status,
Token = pluginConfigurationValue,
})
.ToList();
return(itemListPnCaseResultListModel);
}
