public async Task <OperationResult> Update(RentableItemModel rentableItemPnUpdateModel)
{
try
{
RentableItem rentableItem = await _dbContext.RentableItem.SingleOrDefaultAsync(x => x.Id == rentableItemPnUpdateModel.Id);
if (rentableItem != null)
{
rentableItem.Brand = rentableItemPnUpdateModel.Brand;
rentableItem.ModelName = rentableItemPnUpdateModel.ModelName;
rentableItem.RegistrationDate = rentableItemPnUpdateModel.RegistrationDate;
rentableItem.SerialNumber = rentableItemPnUpdateModel.SerialNumber;
rentableItem.VinNumber = rentableItemPnUpdateModel.VinNumber;
rentableItem.PlateNumber = rentableItemPnUpdateModel.PlateNumber;
rentableItem.eFormId = rentableItemPnUpdateModel.EFormId;
await rentableItem.Update(_dbContext);
}
return(new OperationDataResult <RentableItemsModel>(true,
_rentableItemsLocalizationService.GetString("RentableItemUpdatedSuccessfully")));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <RentableItemsModel>(false,
_rentableItemsLocalizationService.GetString("ErrorWhileUpdatingRentableItemInfo")));
}
}
public async Task RentableItem_Create_DoesCreate()
{
//Arrange
RentableItem rentableItem = new RentableItem
{
Brand = Guid.NewGuid().ToString(),
ModelName = Guid.NewGuid().ToString(),
VinNumber = Guid.NewGuid().ToString(),
SerialNumber = Guid.NewGuid().ToString(),
PlateNumber = Guid.NewGuid().ToString(),
RegistrationDate = DateTime.Now
};
//Act
await rentableItem.Create(DbContext);
RentableItem dbRentableItem = DbContext.RentableItem.AsNoTracking().First();
List <RentableItem> itemList = DbContext.RentableItem.AsNoTracking().ToList();
List <RentableItemVersion> versionList = DbContext.RentableItemsVersion.AsNoTracking().ToList();
// Assert
Assert.NotNull(rentableItem);
Assert.AreEqual(1, itemList.Count());
Assert.AreEqual(1, versionList.Count());
Assert.AreEqual(rentableItem.Brand, dbRentableItem.Brand);
Assert.AreEqual(rentableItem.ModelName, dbRentableItem.ModelName);
Assert.AreEqual(rentableItem.PlateNumber, dbRentableItem.PlateNumber);
Assert.AreEqual(rentableItem.VinNumber, dbRentableItem.VinNumber);
Assert.AreEqual(rentableItem.SerialNumber, dbRentableItem.SerialNumber);
Assert.AreEqual(rentableItem.RegistrationDate.ToString(), dbRentableItem.RegistrationDate.ToString());
Assert.AreEqual(rentableItem.WorkflowState, dbRentableItem.WorkflowState);
}
public async Task <OperationResult> Create(RentableItemModel rentableItemPnCreateModel)
{
try
{
RentableItem rentableItem = new RentableItem
{
Brand = rentableItemPnCreateModel.Brand,
ModelName = rentableItemPnCreateModel.ModelName,
RegistrationDate = rentableItemPnCreateModel.RegistrationDate,
VinNumber = rentableItemPnCreateModel.VinNumber,
SerialNumber = rentableItemPnCreateModel.SerialNumber,
PlateNumber = rentableItemPnCreateModel.PlateNumber,
eFormId = rentableItemPnCreateModel.EFormId
};
await rentableItem.Create(_dbContext);
//_dbContext.RentableItem.Add(rentableItemPn);
//_dbContext.SaveChanges();
return(new OperationResult(true,
_rentableItemsLocalizationService.GetString("RentableItemCreated", rentableItemPnCreateModel.Brand,
rentableItemPnCreateModel.ModelName)));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationResult(true, _rentableItemsLocalizationService.GetString("ErrorWhileCreatingRentableItem")));
}
}
public async Task <OperationDataResult <RentableItemsModel> > Index(int contractId)
{
try
{
RentableItemsModel rentableItemsModel = new RentableItemsModel();
List <ContractRentableItem> itemContractsQuery = await
_dbContext.ContractRentableItem.Where(x => x.ContractId == contractId && x.WorkflowState == Constants.WorkflowStates.Created).ToListAsync();
foreach (var rentableItemContract in itemContractsQuery)
{
RentableItemModel rentableItemModel = new RentableItemModel();
RentableItem rentableItem = await
_dbContext.RentableItem.FirstOrDefaultAsync(y => y.Id == rentableItemContract.RentableItemId);
rentableItemModel.Brand = rentableItem.Brand;
rentableItemModel.VinNumber = rentableItem.VinNumber;
rentableItemModel.RegistrationDate = rentableItem.RegistrationDate;
rentableItemModel.PlateNumber = rentableItem.PlateNumber;
rentableItemModel.ModelName = rentableItem.ModelName;
rentableItemModel.SerialNumber = rentableItem.SerialNumber;
rentableItemModel.Id = rentableItem.Id;
rentableItemsModel.RentableItems.Add(rentableItemModel);
rentableItemsModel.RentableItemIds.Add(rentableItemContract.RentableItemId);
}
return(new OperationDataResult <RentableItemsModel>(true, rentableItemsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <RentableItemsModel>(false, "Could not find any rentable items"));
}
}
private async Task <RentableItem> FindRentableItem(bool brandExists, int brandColumn, bool modelExists, int modelColumn,
bool registrationDateExists, int registrationDateColumn, bool vinNumberExists, int vinNumberColumn,
JToken headers, JToken rentableObj)
{
RentableItem rentableItem = null;
if (brandExists)
{
string brand = rentableObj[brandColumn].ToString();
rentableItem = await _dbContext.RentableItem.SingleOrDefaultAsync(x => x.Brand == brand && x.WorkflowState == Constants.WorkflowStates.Created);
}
if (modelExists)
{
string model = rentableObj[modelColumn].ToString();
rentableItem = await _dbContext.RentableItem.SingleOrDefaultAsync(x => x.ModelName == model && x.WorkflowState == Constants.WorkflowStates.Created);
}
if (registrationDateExists)
{
DateTime registrationDate = (DateTime)rentableObj[registrationDateColumn];
rentableItem =
await _dbContext.RentableItem.SingleOrDefaultAsync(x => x.RegistrationDate == registrationDate && x.WorkflowState == Constants.WorkflowStates.Created);
}
if (vinNumberExists)
{
string vinNumber = rentableObj[vinNumberColumn].ToString();
rentableItem = await _dbContext.RentableItem.SingleOrDefaultAsync(x => x.VinNumber == vinNumber && x.WorkflowState == Constants.WorkflowStates.Created);
}
return(rentableItem);
}
public async Task ContractRentableItem_Delete_DoesDelete()
{
//Arrange
RentableItem rentableItem = new RentableItem
{
Brand = Guid.NewGuid().ToString(),
ModelName = Guid.NewGuid().ToString(),
VinNumber = Guid.NewGuid().ToString(),
SerialNumber = Guid.NewGuid().ToString(),
PlateNumber = Guid.NewGuid().ToString(),
RegistrationDate = DateTime.Now
};
await rentableItem.Create(DbContext);
Random rnd = new Random();
DateTime contractEnd = DateTime.Now;
DateTime contractStart = DateTime.Now;
Contract contract = new Contract
{
Status = 66,
ContractEnd = contractEnd,
ContractNr = rnd.Next(1, 255),
ContractStart = contractStart,
CustomerId = rnd.Next(1, 255)
};
await contract.Create(DbContext);
ContractRentableItem contractRentableItem = new ContractRentableItem
{
ContractId = contract.Id,
RentableItemId = rentableItem.Id
};
await contractRentableItem.Create(DbContext);
//Act
await contractRentableItem.Delete(DbContext);
ContractRentableItem dbContractRentableItem = DbContext.ContractRentableItem.AsNoTracking().First();
List <ContractRentableItem> contractRentableItems = DbContext.ContractRentableItem.AsNoTracking().ToList();
List <ContractRentableItemVersion> versionList =
DbContext.ContractRentableItemVersion.AsNoTracking().ToList();
//Assert
Assert.NotNull(dbContractRentableItem);
Assert.AreEqual(1, contractRentableItems.Count);
Assert.AreEqual(2, versionList.Count);
Assert.AreEqual(contractRentableItem.ContractId, dbContractRentableItem.ContractId);
Assert.AreEqual(contractRentableItem.RentableItemId, dbContractRentableItem.RentableItemId);
Assert.AreEqual(Constants.WorkflowStates.Removed, dbContractRentableItem.WorkflowState);
}
public async Task <OperationResult> Delete(int id)
{
RentableItem rentableItem = await _dbContext.RentableItem.SingleOrDefaultAsync(x => x.Id == id);
try
{
if (rentableItem != null)
{
await rentableItem.Delete(_dbContext);
}
return(new OperationDataResult <RentableItemsModel>(true));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <RentableItemsModel>(true,
_rentableItemsLocalizationService.GetString("ErrorWhileDeletingRentableItem")));
}
}
public async Task <OperationDataResult <RentableItemModel> > Read(int id)
{
RentableItem rentableItem = await _dbContext.RentableItem.SingleOrDefaultAsync(x => x.Id == id);
if (rentableItem != null)
{
RentableItemModel rentableItemModel = new RentableItemModel
{
Id = rentableItem.Id,
Brand = rentableItem.Brand,
ModelName = rentableItem.ModelName,
VinNumber = rentableItem.VinNumber,
SerialNumber = rentableItem.SerialNumber,
PlateNumber = rentableItem.PlateNumber,
RegistrationDate = rentableItem.RegistrationDate,
FullName = $"{rentableItem.Brand} - {rentableItem.ModelName} - {rentableItem.SerialNumber} - {rentableItem.VinNumber} - {rentableItem.PlateNumber}"
};
return(new OperationDataResult <RentableItemModel>(true, rentableItemModel));
}
return(new OperationDataResult <RentableItemModel>(false, _rentableItemsLocalizationService.GetString("ErrorWhileReadingRentableItemInfo")));
}
public async Task <OperationResult> Read(string token)
{
var pluginConfiguration = await _dbContext.PluginConfigurationValues.SingleOrDefaultAsync(x => x.Name == "RentableItemBaseSettings:Token");
if (pluginConfiguration == null)
{
return(new OperationResult(false));
}
if (token == pluginConfiguration.Value)
{
UserCredential credential;
pluginConfiguration = await _dbContext.PluginConfigurationValues.SingleOrDefaultAsync(x => x.Name == "RentableItemBaseSettings:GmailCredentials");
GoogleClientSecrets secrets = NewtonsoftJsonSerializer.Instance.Deserialize <GoogleClientSecrets>(pluginConfiguration.Value);
pluginConfiguration = await _dbContext.PluginConfigurationValues.SingleOrDefaultAsync(x => x.Name == "RentableItemBaseSettings:GmailUserName");
string gmailUserName = pluginConfiguration.Value;
pluginConfiguration = await _dbContext.PluginConfigurationValues.SingleOrDefaultAsync(x => x.Name == "RentableItemBaseSettings:MailFrom");
string mailFrom = pluginConfiguration.Value;
pluginConfiguration = await _dbContext.PluginConfigurationValues.SingleOrDefaultAsync(x => x.Name == "RentableItemBaseSettings:GmailEmail");
string gmailEmail = pluginConfiguration.Value;
pluginConfiguration = await _dbContext.PluginConfigurationValues.SingleOrDefaultAsync(x => x.Name == "RentableItemBaseSettings:SdkeFormId");
int eFormId = int.Parse(pluginConfiguration.Value);
try
{
string credPath = "token.json";
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
secrets.Secrets,
Scopes,
gmailUserName,
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
var service = new GmailService(new BaseClientService.Initializer
{
HttpClientInitializer = credential,
ApplicationName = ApplicationName
});
var emailListRequest = service.Users.Messages.List(gmailEmail);
emailListRequest.LabelIds = "INBOX";
emailListRequest.IncludeSpamTrash = false;
emailListRequest.Q = $"from:{mailFrom}";
emailListRequest.MaxResults = 1;
var emailListResponse = await emailListRequest.ExecuteAsync();
if (emailListResponse != null && emailListResponse.Messages != null)
{
foreach (var email in emailListResponse.Messages)
{
var emailInfoRequest = service.Users.Messages.Get(gmailEmail, email.Id);
var emailInfoResponse = await emailInfoRequest.ExecuteAsync();
if (emailInfoResponse != null)
{
IList <MessagePart> parts = emailInfoResponse.Payload.Parts;
foreach (var part in parts)
{
if (!string.IsNullOrEmpty(part.Filename))
{
string attId = part.Body.AttachmentId;
MessagePartBody attachPart = service.Users.Messages.Attachments
.Get(gmailEmail, email.Id, attId).Execute();
string attachData = attachPart.Data.Replace("-", "+");
attachData = attachData.Replace("_", "/");
byte[] data = Convert.FromBase64String(attachData);
var bytesAsString = Encoding.Default.GetString(data);
string[] rawFile = bytesAsString.Split("\n");
var importList = rawFile.Skip(2);
string[] list = importList.ToArray();
var headers = rawFile[0].Split(",");
foreach (string s in list)
{
string[] lSplit = s.Split("\",\"");
if (lSplit.Length == 8)
{
Contract contract = null;
Customer customer = null;
ContractRentableItem contractRentableItem = null;
try
{
customer = _customerDbContext.Customers.SingleOrDefault(x => x.CompanyName == lSplit[1] || x.ContactPerson == lSplit[1]);
if (customer == null)
{
customer = new Customer
{
CompanyName = lSplit[1]
};
await customer.Create(_customerDbContext);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
RentableItem rentableItem = null;
try
{
rentableItem = _dbContext.RentableItem.SingleOrDefault(x => x.Brand == lSplit[2] && x.ModelName == lSplit[3] && x.RegistrationDate == DateTime.Parse(lSplit[4]));
if (rentableItem == null)
{
rentableItem = new RentableItem
{
Brand = lSplit[2],
ModelName = lSplit[3],
RegistrationDate = DateTime.Parse(lSplit[4]),
VinNumber = lSplit[5],
eFormId = eFormId
};
await rentableItem.Create(_dbContext);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
try
{
contract = _dbContext.Contract.SingleOrDefault(x =>
x.ContractNr == int.Parse(lSplit[0].Replace("\"", "")));
if (contract == null)
{
contract = new Contract
{
ContractNr = int.Parse(lSplit[0].Replace("\"", "")),
ContractStart = DateTime.Parse(lSplit[6]),
ContractEnd = DateTime.Parse(lSplit[7].Replace("\r", "").Replace("\"", "")),
CustomerId = customer.Id,
Status = 0
};
await contract.Create(_dbContext);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
try
{
contractRentableItem =
_dbContext.ContractRentableItem.SingleOrDefault(x =>
x.ContractId == contract.Id &&
x.RentableItemId == rentableItem.Id);
if (contractRentableItem == null)
{
contractRentableItem = new ContractRentableItem
{
ContractId = contract.Id,
RentableItemId = rentableItem.Id
};
await contractRentableItem.Create(_dbContext);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
}
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
return(new OperationResult(true));
}
public async Task <OperationDataResult <ContractInspectionsModel> > Index(ContractInspectionsRequestModel contractInspectionsPnRequestModel)
{
try
{
ContractInspectionsModel contractInspectionsModel = new ContractInspectionsModel();
Core _core = await _coreHelper.GetCore();
IQueryable <ContractInspection> contractInspectionsQuery = _dbContext.ContractInspection.
Where(x => x.WorkflowState != Constants.WorkflowStates.Removed).AsQueryable();
if (!string.IsNullOrEmpty(contractInspectionsPnRequestModel.SortColumnName) &&
contractInspectionsPnRequestModel.SortColumnName != "")
{
if (contractInspectionsPnRequestModel.IsSortDsc)
{
contractInspectionsQuery = contractInspectionsQuery.CustomOrderByDescending(contractInspectionsPnRequestModel.SortColumnName);
}
else
{
contractInspectionsQuery = contractInspectionsQuery.CustomOrderBy(contractInspectionsPnRequestModel.SortColumnName);
}
}
contractInspectionsModel.Total = await contractInspectionsQuery.CountAsync(x => x.WorkflowState != Constants.WorkflowStates.Removed);
contractInspectionsQuery
= contractInspectionsQuery
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Skip(contractInspectionsPnRequestModel.Offset)
.Take(contractInspectionsPnRequestModel.PageSize);
List <ContractInspection> contractInspections = await contractInspectionsQuery.ToListAsync();
contractInspections.ForEach(contractInspection =>
{
ContractInspectionItem contractInspectionItem =
_dbContext.ContractInspectionItem.FirstOrDefault(x =>
x.ContractInspectionId == contractInspection.Id);
Contract contract = _dbContext.Contract.Single(x => x.Id == contractInspection.ContractId);
Customer customer =
_customerDbContext.Customers.Single(x => x.Id == contract.CustomerId);
RentableItemCustomerModel rentableItemCustomerModel = new RentableItemCustomerModel
{
Id = customer.Id,
CustomerNo = customer.CustomerNo,
CompanyName = customer.CompanyName,
ContactPerson = customer.ContactPerson,
CompanyAddress = customer.CompanyAddress,
CompanyAddress2 = customer.CompanyAddress2,
CityName = customer.CityName,
ZipCode = customer.ZipCode,
CountryCode = customer.CountryCode,
EanCode = customer.EanCode,
VatNumber = customer.VatNumber,
Email = customer.Email,
Phone = customer.Phone,
Description = customer.Description
};
List <RentableItemModel> rentableItemModels = new List <RentableItemModel>();
foreach (ContractRentableItem contractRentableItem in _dbContext.ContractRentableItem.Where(x =>
x.ContractId == contract.Id && x.WorkflowState == Constants.WorkflowStates.Created).ToList())
{
RentableItem rentableItem = _dbContext.RentableItem.Single(x => x.Id == contractRentableItem.RentableItemId);
RentableItemModel rentableItemModel = new RentableItemModel
{
Id = rentableItem.Id,
Brand = rentableItem.Brand,
ModelName = rentableItem.ModelName,
PlateNumber = rentableItem.PlateNumber,
VinNumber = rentableItem.VinNumber,
SerialNumber = rentableItem.SerialNumber,
RegistrationDate = rentableItem.RegistrationDate,
EFormId = rentableItem.eFormId
};
rentableItemModels.Add(rentableItemModel);
}
using (var dbContext = _core.DbContextHelper.GetDbContext())
{
if (contractInspectionItem != null)
{
contractInspectionsModel.ContractInspections.Add(new ContractInspectionModel
{
SdkCaseApiId = contractInspectionItem.SDKCaseId,
SdkCaseId = dbContext.Cases
.Single(x => x.MicrotingUid == contractInspectionItem.SDKCaseId).Id,
eFormId = rentableItemModels.First().EFormId,
ContractId = contractInspection.ContractId,
ContractStart = contract.ContractStart,
ContractEnd = contract.ContractEnd,
DoneAt = contractInspection.DoneAt,
Id = contractInspection.Id,
Status = contractInspectionItem.Status,
RentableItemCustomer = rentableItemCustomerModel,
RentableItems = rentableItemModels
});
}
}
});
return(new OperationDataResult <ContractInspectionsModel>(true, contractInspectionsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <ContractInspectionsModel>(false,
_rentableItemsLocalizationService.GetString("ErrorObtainingContractInspectionInfo")));
}
}
public async Task <string> DownloadEFormPdf(int id, string token, string fileType)
{
Core core = await _coreHelper.GetCore();
var locale = await _userService.GetCurrentUserLocale();
var language = core.DbContextHelper.GetDbContext().Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
string microtingUId;
string microtingCheckUId;
int caseId = 0;
int eFormId = 0;
ContractInspection contractInspection =
await _dbContext.ContractInspection.SingleOrDefaultAsync(x => x.Id == id);
Contract contract = _dbContext.Contract.Single(x => x.Id == contractInspection.ContractId);
int i = 0;
XElement xmlContent = new XElement("ContractInspection");
foreach (ContractRentableItem contractRentableItem in _dbContext.ContractRentableItem
.Where(x => x.ContractId == contract.Id &&
x.WorkflowState == Constants.WorkflowStates.Created)
.ToList())
{
RentableItem rentableItem = _dbContext.RentableItem.Single(x => x.Id == contractRentableItem.RentableItemId);
xmlContent.Add(new XElement($"Brand_{i}", rentableItem.Brand));
xmlContent.Add(new XElement($"ModelName_{i}", rentableItem.ModelName));
xmlContent.Add(new XElement($"Serial_{i}", rentableItem.SerialNumber));
xmlContent.Add(new XElement($"RegistrationDate_{i}", rentableItem.RegistrationDate));
xmlContent.Add(new XElement($"vinNumber_{i}", rentableItem.VinNumber));
xmlContent.Add(new XElement($"PlateNumber_{i}", rentableItem.PlateNumber));
i += 1;
}
Customer customer =
_customerDbContext.Customers.Single(x => x.Id == contract.CustomerId);
xmlContent.Add(new XElement("CustomerCustomerNo", customer.CustomerNo));
xmlContent.Add(new XElement("CustomerCompanyName", customer.CompanyName));
xmlContent.Add(new XElement("CustomerContactPerson", customer.ContactPerson));
xmlContent.Add(new XElement("CustomerCompanyAddress", customer.CompanyAddress));
xmlContent.Add(new XElement("CustomerCompanyAddress2", customer.CompanyAddress2));
xmlContent.Add(new XElement("CustomerCityName", customer.CityName));
xmlContent.Add(new XElement("CustomerZipCode", customer.ZipCode));
xmlContent.Add(new XElement("CustomerCountryCode", customer.CountryCode));
xmlContent.Add(new XElement("CustomerEanCode", customer.EanCode));
xmlContent.Add(new XElement("CustomerVatNumber", customer.VatNumber));
xmlContent.Add(new XElement("CustomerEmail", customer.Email));
xmlContent.Add(new XElement("CustomerPhone", customer.Phone));
xmlContent.Add(new XElement("CustomerDescription", customer.Description));
_coreHelper.LogEvent($"DownloadEFormPdf: xmlContent is {xmlContent}");
ContractInspectionItem contractInspectionItem =
_dbContext.ContractInspectionItem.FirstOrDefault(x =>
x.ContractInspectionId == contractInspection.Id);
CaseDto caseDto = await core.CaseLookupMUId(contractInspectionItem.SDKCaseId);
caseId = (int)caseDto.CaseId;
eFormId = caseDto.CheckListId;
if (caseId != 0 && eFormId != 0)
{
_coreHelper.LogEvent($"DownloadEFormPdf: caseId is {caseId}, eFormId is {eFormId}");
var filePath = await core.CaseToPdf(caseId, eFormId.ToString(),
DateTime.Now.ToString("yyyyMMddHHmmssffff"),
$"{await core.GetSdkSetting(Settings.httpServerAddress)}/" + "api/template-files/get-image/", xmlContent.ToString(), language);
if (!File.Exists(filePath))
{
throw new FileNotFoundException();
}
return(filePath);
}
throw new Exception("could not find case of eform!");
}
public async Task <OperationResult> Create(ContractInspectionModel contractInspectionCreateModel)
{
try
{
Core core = await _coreHelper.GetCore();
await using MicrotingDbContext context = core.DbContextHelper.GetDbContext();
// finde eform fra settings
List <ContractRentableItem> contractRentableItem =
await _dbContext.ContractRentableItem.Where(x =>
x.ContractId == contractInspectionCreateModel.ContractId && x.WorkflowState != Constants.WorkflowStates.Removed).ToListAsync();
foreach (var item in contractRentableItem)
{
int rentableItemId = item.RentableItemId;
RentableItem rentableItem =
await _dbContext.RentableItem.FirstOrDefaultAsync(x => x.Id == rentableItemId);
int eFormId = rentableItem.eFormId;
Contract dbContract =
await _dbContext.Contract.FirstOrDefaultAsync(x =>
x.Id == contractInspectionCreateModel.ContractId);
Customer dbCustomer =
await _customersPnDbContext.Customers.SingleOrDefaultAsync(x => x.Id == dbContract.CustomerId);
Site site = await context.Sites.SingleAsync(x => x.Id == contractInspectionCreateModel.SiteId);
Language language = await context.Languages.SingleAsync(x => x.Id == site.LanguageId);
MainElement mainElement = await core.ReadeForm(eFormId, language);
mainElement.Repeated = 1;
mainElement.EndDate = DateTime.Now.AddDays(14).ToUniversalTime();
mainElement.StartDate = DateTime.Now.ToUniversalTime();
mainElement.Label = "";
mainElement.Label += string.IsNullOrEmpty(rentableItem.SerialNumber)
? ""
: $"{rentableItem.SerialNumber}";
mainElement.Label += string.IsNullOrEmpty(rentableItem.VinNumber)
? ""
: $"{rentableItem.VinNumber}";
mainElement.Label += string.IsNullOrEmpty(rentableItem.Brand)
? ""
: $"<br>{rentableItem.Brand}";
mainElement.Label += string.IsNullOrEmpty(rentableItem.ModelName)
? ""
: $"<br>{rentableItem.ModelName}";
mainElement.Label += string.IsNullOrEmpty(dbCustomer.ContactPerson)
? ""
: $"<br>{dbCustomer.ContactPerson}";
CDataValue cDataValue = new CDataValue();
cDataValue.InderValue = $"<b>Kontrakt Nr:<b>{dbContract.ContractNr.ToString()}<br>";
cDataValue.InderValue += $"<b>Kunde Nr:<b>{dbContract.CustomerId.ToString()}";
List <SiteDto> sites = new List <SiteDto>();
int?sdkCaseId = await core.CaseCreate(mainElement, "", (int)site.MicrotingUid, null);
if (sdkCaseId != null)
{
ContractInspection contractInspection = new ContractInspection
{
ContractId = contractInspectionCreateModel.ContractId
};
await contractInspection.Create(_dbContext);
ContractInspectionItem contractInspectionItem = new ContractInspectionItem
{
ContractInspectionId = contractInspection.Id,
RentableItemId = rentableItemId,
SiteId = site.Id,
SDKCaseId = (int)sdkCaseId,
Status = 33
};
await contractInspectionItem.Create(_dbContext);
}
}
return(new OperationResult(true, "Inspection Created Successfully"));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationResult(false, _rentableItemsLocalizationService.GetString("ErrorWhileCreatingContractInspection")));
}
}
public async Task ContractInspectionItem_Update_DoesUpdate()
{
//Arrange
Random rnd = new Random();
DateTime contractEnd = DateTime.Now;
DateTime contractStart = DateTime.Now;
Contract contract = new Contract
{
Status = 66,
ContractEnd = contractEnd,
ContractNr = rnd.Next(1, 255),
ContractStart = contractStart,
CustomerId = rnd.Next(1, 255)
};
await contract.Create(DbContext);
Contract contract2 = new Contract
{
Status = 100,
ContractEnd = contractEnd,
ContractNr = rnd.Next(1, 255),
ContractStart = contractStart,
CustomerId = rnd.Next(1, 255)
};
await contract2.Create(DbContext);
RentableItem rentableItem = new RentableItem
{
ModelName = Guid.NewGuid().ToString(),
Brand = Guid.NewGuid().ToString(),
RegistrationDate = DateTime.Now,
VinNumber = Guid.NewGuid().ToString(),
PlateNumber = Guid.NewGuid().ToString(),
SerialNumber = Guid.NewGuid().ToString(),
eFormId = rnd.Next(1, 255)
};
RentableItem rentableItem2 = new RentableItem
{
Brand = Guid.NewGuid().ToString(),
ModelName = Guid.NewGuid().ToString(),
VinNumber = Guid.NewGuid().ToString(),
SerialNumber = Guid.NewGuid().ToString(),
PlateNumber = Guid.NewGuid().ToString(),
RegistrationDate = DateTime.Now.AddDays(1)
};
ContractInspection contractInspection = new ContractInspection
{
ContractId = contract.Id,
DoneAt = DateTime.Now,
};
await contractInspection.Create(DbContext);
ContractInspection contractInspection2 = new ContractInspection
{
ContractId = contract2.Id,
DoneAt = DateTime.Now.AddDays(1)
};
ContractInspectionItem inspectionItem = new ContractInspectionItem
{
ContractInspectionId = contractInspection.Id,
RentableItemId = rentableItem.Id,
SDKCaseId = rnd.Next(1, 66),
SiteId = rnd.Next(1, 999999),
Status = 66
};
await inspectionItem.Create(DbContext);
inspectionItem.Status = 100;
inspectionItem.SDKCaseId = rnd.Next(1, 255);
inspectionItem.SiteId = rnd.Next(1, 255);
inspectionItem.ContractInspectionId = contractInspection2.Id;
inspectionItem.RentableItemId = rentableItem2.Id;
//Act
await inspectionItem.Update(DbContext);
ContractInspectionItem dbInspectionItem =
await DbContext.ContractInspectionItem.AsNoTracking().FirstAsync();
List <ContractInspectionItem> inspectionItems =
await DbContext.ContractInspectionItem.AsNoTracking().ToListAsync();
List <ContractInspectionItemVersion> versionList =
await DbContext.ContractInspectionItemVersion.AsNoTracking().ToListAsync();
//Assert
Assert.NotNull(dbInspectionItem);
Assert.NotNull(inspectionItems);
Assert.NotNull(versionList);
Assert.AreEqual(inspectionItem.Status, dbInspectionItem.Status);
Assert.AreEqual(inspectionItem.ContractInspectionId, dbInspectionItem.ContractInspectionId);
Assert.AreEqual(inspectionItem.RentableItemId, dbInspectionItem.RentableItemId);
Assert.AreEqual(inspectionItem.SDKCaseId, dbInspectionItem.SDKCaseId);
Assert.AreEqual(inspectionItem.SiteId, dbInspectionItem.SiteId);
}
public async Task <OperationDataResult <ContractsModel> > Index(ContractsRequestModel contractsPnRequestModel)
{
try
{
ContractsModel contractsModel = new ContractsModel();
IQueryable <Contract> contractsQuery = _dbContext.Contract.
Where(x => x.WorkflowState != Constants.WorkflowStates.Removed).AsQueryable();
if (!string.IsNullOrEmpty(contractsPnRequestModel.SortColumnName))
{
if (contractsPnRequestModel.IsSortDsc)
{
contractsQuery = contractsQuery.CustomOrderByDescending(contractsPnRequestModel.SortColumnName);
}
else
{
contractsQuery = contractsQuery.CustomOrderBy(contractsPnRequestModel.SortColumnName);
}
}
contractsModel.Total = contractsQuery.Count();
contractsQuery
= contractsQuery
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Skip(contractsPnRequestModel.Offset)
.Take(contractsPnRequestModel.PageSize);
List <Contract> contracts = await contractsQuery.ToListAsync();
contracts.ForEach(contract =>
{
var customer =
_customerDbContext.Customers.Single(x => x.Id == contract.CustomerId);
RentableItemCustomerModel rentableItemCustomerModel = new RentableItemCustomerModel
{
Id = customer.Id,
CustomerNo = customer.CustomerNo,
CompanyName = customer.CompanyName,
ContactPerson = customer.ContactPerson,
CompanyAddress = customer.CompanyAddress,
CompanyAddress2 = customer.CompanyAddress2,
CityName = customer.CityName,
ZipCode = customer.ZipCode,
CountryCode = customer.CountryCode,
EanCode = customer.EanCode,
VatNumber = customer.VatNumber,
Email = customer.Email,
Phone = customer.Phone,
Description = customer.Description
};
List <RentableItemModel> rentableItemModels = new List <RentableItemModel>();
foreach (ContractRentableItem contractRentableItem in _dbContext.ContractRentableItem.Where(x => x.ContractId == contract.Id && x.WorkflowState == Constants.WorkflowStates.Created).ToList())
{
RentableItem rentableItem = _dbContext.RentableItem.Single(x => x.Id == contractRentableItem.RentableItemId);
RentableItemModel rentableItemModel = new RentableItemModel
{
Id = rentableItem.Id,
Brand = rentableItem.Brand,
ModelName = rentableItem.ModelName,
PlateNumber = rentableItem.PlateNumber,
VinNumber = rentableItem.VinNumber,
SerialNumber = rentableItem.SerialNumber,
RegistrationDate = rentableItem.RegistrationDate
};
rentableItemModels.Add(rentableItemModel);
}
contractsModel.Contracts.Add(new ContractModel
{
ContractEnd = contract.ContractEnd,
ContractNr = contract.ContractNr,
ContractStart = contract.ContractStart,
CustomerId = contract.CustomerId,
RentableItemCustomer = rentableItemCustomerModel,
RentableItems = rentableItemModels,
Id = contract.Id,
});
});
return(new OperationDataResult <ContractsModel>(true, contractsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <ContractsModel>(false,
_rentableItemsLocalizationService.GetString("ErrorObtainingContracts")));
}
}
public async Task <OperationResult> Import(ImportModel importModel)
{
try
{
JToken rawJson = JToken.Parse(importModel.ImportList);
int eFormId = importModel.eFormId;
JToken rawHeadersJson = JToken.Parse(importModel.Headers);
JToken headers = rawHeadersJson;
IEnumerable <JToken> rentableObjects = rawJson.Skip(2);
Core core = await _coreHelper.GetCore();
foreach (JToken rentableObject in rentableObjects)
{
Customer customer = null;
bool companyNameExists = int.TryParse(headers[1]["headerValue"].ToString(), out int companyNameColumn);
if (companyNameExists)
{
customer = await FindCustomer(companyNameExists, companyNameColumn, headers, rentableObject);
if (customer == null)
{
CustomerFullModel customerModel =
CustomerHelper.ComposeValues(new CustomerFullModel(), headers, rentableObject);
customer = new Customer
{
CompanyName = customerModel.CompanyName
};
await customer.Create(_customerDbContext);
}
}
RentableItem rentableItem = null;
bool brandExists = int.TryParse(headers[2]["headerValue"].ToString(), out int brandColumn);
bool modelExists = int.TryParse(headers[3]["headerValue"].ToString(), out int modelColumn);
bool registrationDateExists =
int.TryParse(headers[4]["headerValue"].ToString(), out int registrationDateColumn);
bool vinNumberExists = int.TryParse(headers[5]["headerValue"].ToString(), out int vinNumberColumn);
if (brandExists &&
modelExists &&
registrationDateExists &&
vinNumberExists)
{
rentableItem = await FindRentableItem(brandExists, brandColumn, modelExists, modelColumn,
registrationDateExists, registrationDateColumn, vinNumberExists, vinNumberColumn, headers,
rentableObject);
if (rentableItem == null)
{
RentableItemModel rentableItemModel =
RentableItemHelper.ComposeValues(new RentableItemModel(), headers, rentableObject);
rentableItem = new RentableItem
{
Brand = rentableItemModel.Brand,
ModelName = rentableItemModel.ModelName,
RegistrationDate = rentableItemModel.RegistrationDate,
VinNumber = rentableItemModel.VinNumber,
eFormId = eFormId
};
await rentableItem.Create(_dbContext);
}
}
Contract contract = null;
bool contractNumberExists =
int.TryParse(headers[0]["headerValue"].ToString(), out int contractNumberColumn);
bool contractStartExists =
int.TryParse(headers[6]["headerValue"].ToString(), out int contractStartColumn);
bool contractEndExists = int.TryParse(headers[7]["headerValue"].ToString(), out int contractEndColumn);
int customerID = customer.Id;
if (contractNumberExists &&
contractStartExists &&
contractEndExists &&
customerID != null)
{
contract = await FindContract(contractNumberExists, contractNumberColumn, contractStartExists,
contractStartColumn, contractEndExists, contractEndColumn, customerID, headers, rentableObject);
if (contract == null)
{
ContractModel contractModel =
ContractsHelper.ComposeValues(new ContractModel(), headers, rentableObject);
contract = new Contract
{
CustomerId = customerID,
ContractEnd = contractModel.ContractEnd,
ContractStart = contractModel.ContractStart,
ContractNr = contractModel.ContractNr
};
await contract.Create(_dbContext);
}
}
ContractRentableItem contractRentableItem = null;
if (contract.Id != null && rentableItem.Id != null)
{
contractRentableItem = await FindtContractRentableItem(contract.Id, rentableItem.Id);
if (contractRentableItem == null)
{
contractRentableItem = new ContractRentableItem
{
ContractId = contract.Id,
RentableItemId = rentableItem.Id
};
await contractRentableItem.Create(_dbContext);
}
}
}
return(new OperationResult(true, "Import Successful"));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationResult(false, "You goofed up"));
}
}
