public long UpdateImporterDepotAndPerson(UserProfileObject person)
{
try
{
if (person == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var existing = db.Importers.Where(i => i.Id == person.CompanyId).ToList();
if (!existing.Any())
{
return(-2);
}
var importer = existing[0];
var existingDepot = db.Depots.Where(i => i.ImporterId == importer.Id).ToList();
if (!existingDepot.Any())
{
return(-2);
}
var existingp = db.People.Where(i => i.Id == person.PersonId).ToList();
if (!existingp.Any())
{
return(-2);
}
importer.Name = person.CompanyName;
importer.IsActive = person.IsActive;
var prs = existingp[0];
prs.FirstName = person.FirstName;
prs.LastName = person.LastName;
var depotEntity = existingDepot[0];
depotEntity.Name = person.CompanyName;
db.Entry(importer).State = EntityState.Modified;
db.SaveChanges();
db.Entry(prs).State = EntityState.Modified;
db.SaveChanges();
db.Entry(depotEntity).State = EntityState.Modified;
db.SaveChanges();
return(importer.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateFormM(FormMDetailObject formM)
{
try
{
if (formM == null)
{
return(-2);
}
var formMEntity = ModelMapper.Map <FormMDetailObject, FormMDetail>(formM);
if (formMEntity == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var oldFormMs = db.FormMDetails.Where(v => v.Id == formM.Id).ToList();
if (!oldFormMs.Any())
{
return(-2);
}
var docs = db.Documents.Where(v => v.DocumentId == formM.AttachedDocumentId).ToList();
if (!docs.Any())
{
return(-2);
}
var doc = docs[0];
if (doc.DocumentPath != formM.DocumentPath)
{
doc.DocumentPath = formM.DocumentPath;
doc.DateUploaded = formM.DateAttached;
db.Entry(doc).State = EntityState.Modified;
db.SaveChanges();
}
var formMDetail = oldFormMs[0];
formMDetail.FormMReference = formM.FormMReference;
formMDetail.Quantity = formM.Quantity;
formMDetail.LetterOfCreditNo = formM.LetterOfCreditNo;
formMDetail.AttachedDocumentId = formM.AttachedDocumentId;
formMDetail.DateAttached = formM.DateAttached;
db.Entry(formMEntity).State = EntityState.Modified;
db.SaveChanges();
return(formMEntity.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateThroughPut(ThroughPutObject throughPut)
{
try
{
if (throughPut == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (throughPut.DocumentObject != null && throughPut.DocumentObject.DocumentId > 0)
{
var documentEntities = db.Documents.Where(th => th.DocumentId == throughPut.DocumentObject.DocumentId).ToList();
if (!documentEntities.Any())
{
return(-2);
}
var documentEntity = documentEntities[0];
documentEntity.UploadedById = throughPut.DocumentObject.UploadedById;
documentEntity.IpAddress = throughPut.DocumentObject.IpAddress;
documentEntity.Status = (int)AppStatus.Pending;
documentEntity.DateUploaded = DateTime.Now;
documentEntity.DocumentPath = throughPut.DocumentObject.DocumentPath;
db.Entry(documentEntity).State = EntityState.Modified;
db.SaveChanges();
}
var throughPutEntities = db.ThroughPuts.Where(th => th.Id == throughPut.Id).ToList();
if (!throughPutEntities.Any())
{
return(-2);
}
var throughPutEntity = throughPutEntities[0];
throughPutEntity.Quantity = throughPut.Quantity;
throughPutEntity.IPAddress = throughPut.IPAddress;
db.Entry(throughPutEntity).State = EntityState.Modified;
db.SaveChanges();
return(throughPutEntity.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateDocument(DocumentObject document)
{
try
{
if (document == null)
{
return(-2);
}
var documentEntity = ModelMapper.Map <DocumentObject, Document>(document);
if (documentEntity == null || documentEntity.DocumentId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Documents.Attach(documentEntity);
db.Entry(documentEntity).State = EntityState.Modified;
db.SaveChanges();
return(document.DocumentId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateImportClass(ImportClassObject importClass)
{
try
{
if (importClass == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.ImportClasses.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == importClass.Name.ToLower().Trim().Replace(" ", "") && g.Id != importClass.Id) > 0)
{
return(-3);
}
var importClassEntity = ModelMapper.Map <ImportClassObject, ImportClass>(importClass);
if (importClassEntity == null || importClassEntity.Id < 1)
{
return(-2);
}
db.ImportClasses.Attach(importClassEntity);
db.Entry(importClassEntity).State = EntityState.Modified;
db.SaveChanges();
return(importClass.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public int UpdateBankBranchForReg(BankBranchObject bankBranch)
{
try
{
if (bankBranch == null || bankBranch.BankId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var existings = db.BankBranches.Where(m => m.Id == bankBranch.Id).ToList();
if (!existings.Any())
{
return(-2);
}
var branch = existings[0];
branch.Name = bankBranch.Name;
branch.BranchCode = bankBranch.BranchCode;
db.Entry(branch).State = EntityState.Modified;
db.SaveChanges();
return(branch.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateRecertification(RecertificationObject recertification)
{
try
{
if (recertification == null)
{
return(-2);
}
var recertificationEntity = ModelMapper.Map <RecertificationObject, Recertification>(recertification);
if (recertificationEntity == null || recertificationEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Recertifications.Attach(recertificationEntity);
db.Entry(recertificationEntity).State = EntityState.Modified;
db.SaveChanges();
return(recertification.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateApplicationItems(List <ApplicationItemObject> importItems, List <ApplicationItemObject> oldImportItems, long applicationId)
{
try
{
if (!importItems.Any())
{
return(-2);
}
var successCount = 0;
using (var db = new ImportPermitEntities())
{
var existingItems = db.ApplicationItems.Where(v => v.ApplicationId == applicationId).ToList();
importItems.ForEach(importItem =>
{
var existingItem = existingItems.Find(o => o.ProductId == importItem.ProductId);
if (existingItem != null && existingItem.Id > 0)
{
existingItem.EstimatedQuantity = importItem.EstimatedQuantity;
existingItem.EstimatedValue = importItem.EstimatedValue;
existingItem.PSFNumber = importItem.PSFNumber;
existingItem.ReferenceLicenseCode = importItem.ReferenceLicenseCode;
db.Entry(existingItem).State = EntityState.Modified;
db.SaveChanges();
successCount += 1;
}
else
{
importItem.ApplicationId = applicationId;
var importItemEntity = ModelMapper.Map <ApplicationItemObject, ApplicationItem>(importItem);
if (importItemEntity != null && importItemEntity.ApplicationId > 0)
{
db.ApplicationItems.Add(importItemEntity);
db.SaveChanges();
successCount += 1;
}
}
});
oldImportItems.ForEach(importItem =>
{
if (!importItems.Exists(h => h.ProductId == importItem.ProductId))
{
var myItems = db.ApplicationItems.Where(m => m.ProductId == importItem.ProductId && m.ApplicationId == importItem.ApplicationId).ToList();
if (myItems.Any())
{
db.ApplicationItems.Remove(myItems[0]);
db.SaveChanges();
}
}
});
return(successCount);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateUnitOfMeasurement(UnitOfMeasurementObject unitOfMeasurement)
{
try
{
if (unitOfMeasurement == null)
{
return(-2);
}
var unitOfMeasurementEntity = ModelMapper.Map <UnitOfMeasurementObject, UnitOfMeasurement>(unitOfMeasurement);
if (unitOfMeasurementEntity == null || unitOfMeasurementEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.UnitOfMeasurements.Attach(unitOfMeasurementEntity);
db.Entry(unitOfMeasurementEntity).State = EntityState.Modified;
db.SaveChanges();
return(unitOfMeasurement.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateImportSetting(ImportSettingObject ImportSetting)
{
try
{
if (ImportSetting == null)
{
return(-2);
}
var ImportSettingEntity = ModelMapper.Map <ImportSettingObject, ImportSetting>(ImportSetting);
if (ImportSettingEntity == null || ImportSettingEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.ImportSettings.Attach(ImportSettingEntity);
db.Entry(ImportSettingEntity).State = EntityState.Modified;
db.SaveChanges();
return(ImportSetting.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateCustomCode(CustomCodeObject customCode)
{
try
{
if (customCode == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.CustomCodes.Count(k => k.Name.ToLower().Trim() == customCode.Name.ToLower().Trim() && k.CustomCodeId == customCode.CustomCodeId) > 0)
{
return(-3);
}
var customCodeEntity = ModelMapper.Map <CustomCodeObject, CustomCode>(customCode);
if (customCodeEntity == null || customCodeEntity.CustomCodeId < 1)
{
return(-2);
}
db.CustomCodes.Attach(customCodeEntity);
db.Entry(customCodeEntity).State = EntityState.Modified;
db.SaveChanges();
return(customCode.CustomCodeId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateCountry(CountryObject country)
{
try
{
if (country == null)
{
return(-2);
}
var countryEntity = ModelMapper.Map <CountryObject, Country>(country);
if (countryEntity == null || countryEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.Countries.Count(f => f.Name.ToLower().Trim() == country.Name.ToLower().Trim() && f.Id != country.Id) > 0)
{
return(-3);
}
db.Countries.Attach(countryEntity);
db.Entry(countryEntity).State = EntityState.Modified;
db.SaveChanges();
return(country.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateDepotOwner(DepotOwnerObject depotOwner)
{
try
{
if (depotOwner == null)
{
return(-2);
}
var depotOwnerEntity = ModelMapper.Map <DepotOwnerObject, DepotOwner>(depotOwner);
if (depotOwnerEntity == null || depotOwnerEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.DepotOwners.Attach(depotOwnerEntity);
db.Entry(depotOwnerEntity).State = EntityState.Modified;
db.SaveChanges();
return(depotOwner.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateFaq(FaqObject faq)
{
try
{
if (faq == null)
{
return(-2);
}
var faqEntity = ModelMapper.Map <FaqObject, Faq>(faq);
if (faqEntity == null || faqEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Faqs.Attach(faqEntity);
db.Entry(faqEntity).State = EntityState.Modified;
db.SaveChanges();
return(faq.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateApplicationContent(ApplicationContentObject applicationContent)
{
try
{
if (applicationContent == null)
{
return(-2);
}
var applicationContentEntity = ModelMapper.Map <ApplicationContentObject, ApplicationContent>(applicationContent);
if (applicationContentEntity == null || applicationContentEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.ApplicationContents.Attach(applicationContentEntity);
db.Entry(applicationContentEntity).State = EntityState.Modified;
db.SaveChanges();
return(applicationContent.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateZone(ZoneObject zone)
{
try
{
if (zone == null)
{
return(-2);
}
var zoneEntity = ModelMapper.Map <ZoneObject, Zone>(zone);
if (zoneEntity == null || zoneEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Zones.Attach(zoneEntity);
db.Entry(zoneEntity).State = EntityState.Modified;
db.SaveChanges();
return(zone.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateBankerDocument(DocumentObject document)
{
try
{
if (document == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
var documentEntities = db.Documents.Where(d => d.DocumentId == document.DocumentId).ToList();
if (!documentEntities.Any())
{
return(-2);
}
var documentEntity = documentEntities[0];
documentEntity.DateUploaded = document.DateUploaded;
documentEntity.UploadedById = document.UploadedById;
documentEntity.DocumentPath = document.DocumentPath;
db.Entry(documentEntity).State = EntityState.Modified;
db.SaveChanges();
return(documentEntity.DocumentId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateProductColumn(ProductColumnObject productColumn)
{
try
{
if (productColumn == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.ProductColumns.Count(k => k.CustomCodeId == productColumn.CustomCodeId && k.ProductId == productColumn.ProductId && k.ProductColumnId != productColumn.ProductColumnId) > 0)
{
return(-3);
}
var productColumnEntity = ModelMapper.Map <ProductColumnObject, ProductColumn>(productColumn);
if (productColumnEntity == null || productColumnEntity.ProductColumnId < 1)
{
return(-2);
}
db.ProductColumns.Attach(productColumnEntity);
db.Entry(productColumnEntity).State = EntityState.Modified;
db.SaveChanges();
return(productColumn.ProductColumnId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateNotificationInspectionQueue(NotificationInspectionQueueObject notificationInspectionQueue)
{
try
{
if (notificationInspectionQueue == null)
{
return(-2);
}
var notificationInspectionQueueEntity = ModelMapper.Map <NotificationInspectionQueueObject, NotificationInspectionQueue>(notificationInspectionQueue);
if (notificationInspectionQueueEntity == null || notificationInspectionQueueEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.NotificationInspectionQueues.Attach(notificationInspectionQueueEntity);
db.Entry(notificationInspectionQueueEntity).State = EntityState.Modified;
db.SaveChanges();
return(notificationInspectionQueue.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateBank(BankObject bank)
{
try
{
if (bank == null)
{
return(-2);
}
var bankEntity = ModelMapper.Map <BankObject, Bank>(bank);
if (bankEntity == null || bankEntity.BankId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.Banks.Count(m => (m.SortCode.ToLower() == bank.SortCode.ToLower() || m.Name.ToLower().Trim() == bank.Name.ToLower().Trim()) && m.BankId != bank.BankId) > 0)
{
return(-3);
}
db.Banks.Attach(bankEntity);
db.Entry(bankEntity).State = EntityState.Modified;
db.SaveChanges();
return(bank.BankId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateAccountType(AccountTypeObject accountType)
{
try
{
if (accountType == null)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
if (db.AccountTypes.Count(g => g.Name.ToLower().Trim().Replace(" ", "") == accountType.Name.ToLower().Trim().Replace(" ", "") && g.AccountTypeId != accountType.AccountTypeId) > 0)
{
return(-3);
}
var accountTypeEntity = ModelMapper.Map <AccountTypeObject, AccountType>(accountType);
if (accountTypeEntity == null || accountTypeEntity.AccountTypeId < 1)
{
return(-2);
}
db.AccountTypes.Attach(accountTypeEntity);
db.Entry(accountTypeEntity).State = EntityState.Modified;
db.SaveChanges();
return(accountType.AccountTypeId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdatePort(PortObject port)
{
try
{
if (port == null)
{
return(-2);
}
var portEntity = ModelMapper.Map <PortObject, Port>(port);
if (portEntity == null || portEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Ports.Attach(portEntity);
db.Entry(portEntity).State = EntityState.Modified;
db.SaveChanges();
return(port.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateImportApplicationHistory(ImportApplicationHistoryObject importApplicationHistory)
{
try
{
if (importApplicationHistory == null)
{
return(-2);
}
var importApplicationHistoryEntity = ModelMapper.Map <ImportApplicationHistoryObject, ImportApplicationHistory>(importApplicationHistory);
if (importApplicationHistoryEntity == null || importApplicationHistoryEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.ImportApplicationHistories.Attach(importApplicationHistoryEntity);
db.Entry(importApplicationHistoryEntity).State = EntityState.Modified;
db.SaveChanges();
return(importApplicationHistory.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateProductColour(ProductColourObject productColour)
{
try
{
if (productColour == null)
{
return(-2);
}
var productColourEntity = ModelMapper.Map <ProductColourObject, ProductColour>(productColour);
if (productColourEntity == null || productColourEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.ProductColours.Attach(productColourEntity);
db.Entry(productColourEntity).State = EntityState.Modified;
db.SaveChanges();
return(productColour.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateApplicationItem(ApplicationItemObject importItem)
{
try
{
if (importItem == null)
{
return(-2);
}
var importItemEntity = ModelMapper.Map <ApplicationItemObject, ApplicationItem>(importItem);
if (importItemEntity == null || importItemEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.ApplicationItems.Attach(importItemEntity);
db.Entry(importItemEntity).State = EntityState.Modified;
db.SaveChanges();
return(importItem.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateGroup(GroupObject group)
{
try
{
if (group == null)
{
return(-2);
}
var groupEntity = ModelMapper.Map <GroupObject, Group>(group);
if (groupEntity == null || groupEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Groups.Attach(groupEntity);
db.Entry(groupEntity).State = EntityState.Modified;
db.SaveChanges();
return(group.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateInvoiceItem(InvoiceItemObject fee)
{
try
{
if (fee == null)
{
return(-2);
}
var invoiceItemEntity = ModelMapper.Map <InvoiceItemObject, InvoiceItem>(fee);
if (invoiceItemEntity == null || invoiceItemEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.InvoiceItems.Attach(invoiceItemEntity);
db.Entry(invoiceItemEntity).State = EntityState.Modified;
db.SaveChanges();
return(fee.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateJetty(JettyObject jetty)
{
try
{
if (jetty == null)
{
return(-2);
}
var jettyEntity = ModelMapper.Map <JettyObject, Jetty>(jetty);
if (jettyEntity == null || jettyEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Jetties.Attach(jettyEntity);
db.Entry(jettyEntity).State = EntityState.Modified;
db.SaveChanges();
return(jetty.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateIssue(IssueObject issue)
{
try
{
if (issue == null)
{
return(-2);
}
var issueEntity = ModelMapper.Map <IssueObject, Issue>(issue);
if (issueEntity == null || issueEntity.Id < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Issues.Attach(issueEntity);
db.Entry(issueEntity).State = EntityState.Modified;
db.SaveChanges();
return(issue.Id);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public long UpdateStructure(StructureObject structure)
{
try
{
if (structure == null)
{
return(-2);
}
var structureEntity = ModelMapper.Map <StructureObject, Structure>(structure);
if (structureEntity == null || structureEntity.StructureId < 1)
{
return(-2);
}
using (var db = new ImportPermitEntities())
{
db.Structures.Attach(structureEntity);
db.Entry(structureEntity).State = EntityState.Modified;
db.SaveChanges();
return(structure.StructureId);
}
}
catch (Exception ex)
{
ErrorLogger.LoggError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
