public FieldsProcessorImpl(
InitializationParams initializationParams,
IEnumerable <string> inputFieldNames,
IEnumerable <ExtensionInfo> extensions,
Persistence.IStorageEntry cacheEntry,
LJTraceSource trace,
Telemetry.ITelemetryCollector telemetryCollector,
IMetadataReferencesProvider metadataReferencesProvider,
IAssemblyLoader assemblyLoader
)
{
if (inputFieldNames == null)
{
throw new ArgumentNullException(nameof(inputFieldNames));
}
initializationParams.InitializeInstance(this);
if (extensions != null)
{
this.extensions.AddRange(extensions);
}
this.inputFieldNames = inputFieldNames.Select((name, idx) => name ?? string.Format("Field{0}", idx)).ToList();
this.cacheEntry = cacheEntry;
this.trace = trace;
this.telemetryCollector = telemetryCollector;
this.metadataReferencesProvider = metadataReferencesProvider;
this.assemblyLoader = assemblyLoader;
}
// Similar to [RafaelEstevam.Simple.Spider.Test.Sample.BooksToScrape],
// see for more in depth cover of the crawling part
public static void run()
{
// Creates a new instance
var storage = new Storage.SQLiteStorage <Quote>();
// set the spider to use it
var init = new InitializationParams()
.SetStorage(storage);
var spider = new SimpleSpider("QuotesToScrape",
new Uri("http://quotes.toscrape.com/"),
init);
Console.WriteLine($"The sqlite database is at {storage.DatabaseFilePath}");
Console.WriteLine($"The quotes are being stored in the table {storage.TableNameOfT}");
spider.FetchCompleted += spider_FetchCompleted;
spider.ShouldFetch += Spider_ShouldFetch;
spider.Execute();
Console.WriteLine("Quotes from Albert Einstein");
foreach (Quote q in storage.GetItemsWith("Author", "Albert Einstein"))
{
Console.WriteLine($"{q.Author}: {q.Text}");
}
Console.WriteLine("All Quotes");
foreach (Quote q in spider.Storage.RetrieveAllItems())
{
Console.WriteLine($"{q.Author}: {q.Text}");
}
}
private TraceListener(InitializationParams initializationParams)
: base(initializationParams.FileName)
{
writer = new Lazy <TextWriter>(() =>
{
if (string.IsNullOrEmpty(initializationParams.FileName))
{
return(null);
}
try
{
return(new StreamWriter(initializationParams.FileName, false));
}
catch
{
return(null);
}
}, true);
if (initializationParams.EnableMemBuffer)
{
enableMemBuffer = true;
memBuffer = new CircularBuffer(memBufMaxSize);
}
enableConsole = initializationParams.EnableConsole;
this.enableLogicalThread = initializationParams.EnableLogicalThread;
lastInstance = this;
}
public static void run()
{
var init = new InitializationParams()
.SetCacher(new ContentCacher())
.SetDownloader(new WebClientDownloader())
//.SetOfflineMode() // Remove all downloaders (sets a NullDownloader)
.SetConfig(c => c.Enable_Caching()
.Disable_Cookies()
.Enable_AutoAnchorsLinks() // enable automatic link following
.Set_CachingNoLimit()
.Set_DownloadDelay(5000));
var spider = new SimpleSpider("QuotesToScrape", new Uri("http://quotes.toscrape.com/"), init);
// Defines pages that should not be fetched
spider.ShouldFetch += (_, args)
// ShouldFetch args also supports chaining to easy cancel resources
// Note: the order is very important
=> args.CancelIfContains("/login")
.CancelIfContains("/tag/") // not fetch tags
.AllowIfContains("/tag/choices/") // I like to have choices =)
;
//Defines pages (or ages) that should not use local cache
spider.ShouldUseCache += (_, args)
// can be chained too
=> args.CancelIfOlderThan(new TimeSpan(24, 0, 0));
// Sets up the fetch completed callback
spider.FetchCompleted += Spider_FetchCompleted;
// execute
spider.Execute();
}
public void Catalogar(int ano)
{
Senadores = new List <Lib.Senado.Leg.Senador>();
// obter listagem
var page = FetchHelper.FetchResourceDocument(new Uri("https://www25.senado.leg.br/web/transparencia/sen/"),
enableCaching: true);
var select = new Select(page.DocumentNode.SelectSingleNode("//select"));
var idsSenadores = select.GetItems()
.Select(id => id.Value.Trim())
.Where(id => !string.IsNullOrEmpty(id));
// caminhar pelo site do senado obtendo os demais dados
var init = InitializationParams
.Default002()
.SetConfig(c => c.Disable_AutoAnchorsLinks());
var spider = new SimpleSpider("Senado.Leg",
new System.Uri("https://www6g.senado.leg.br/"),
init);
spider.FetchCompleted += Spider_FetchCompleted;
foreach (var i in idsSenadores)
{
spider.AddPage(montarUriSenador(ano, i),
spider.BaseUri);
}
spider.Execute();
}
private async Task SavePayrollCompanyConfigurationAsync(InitializationParams parameters, Guid companyID)
{
var middlewareManager = new MiddlewareManager <PayrollCompanyConfiguration>(new BaseRecordManager <PayrollCompanyConfiguration>(),
new PayrollCompanyConfigurationValidator());
await middlewareManager.CreateAsync(new List <PayrollCompanyConfiguration>() { parameters.PayrollCompanyConfiguration }, companyID);
}
private TraceListener(InitializationParams initializationParams)
: base(initializationParams.FileName)
{
writer = new Lazy <TextWriter>(() =>
{
if (string.IsNullOrEmpty(initializationParams.FileName))
{
return(null);
}
try
{
return(new StreamWriter(initializationParams.FileName, false));
}
catch
{
return(null);
}
}, true);
if (initializationParams.EnableMemBuffer)
{
enableMemBuffer = true;
memBuffer = new ConcurrentQueue <Entry>();
}
lastInstance = this;
}
public void InitializationParams_SafetyCheck_Default002()
{
var init = InitializationParams.Default002();
var ls = serializeParams(init).ToArray();
string[] expected =
{
"Cacher: RafaelEstevam.Simple.Spider.Cachers.ContentCacher",
"Downloader: RafaelEstevam.Simple.Spider.Downloaders.HttpClientDownloader",
"LinkCollector: RafaelEstevam.Simple.Spider.LinkProcessors.SimpleProcessor",
"SpiderDirectory: ",
"Parsers: 0",
"Config.SpiderDirectory ",
"Config.SpiderDataDirectory ",
"Config.Spider_LogFile ",
"Config.Logger ",
"Config.Auto_RewriteRemoveFragment True",
"Config.Cache_Enable True",
"Config.Cache_Lifetime ",
"Config.DownloadDelay 5000",
"Config.Cookies_Enable False",
"Config.Paused False",
"Config.Paused_Cacher False",
"Config.Paused_Downloader False",
"Config.Auto_AnchorsLinks True",
"Config.SpiderAllowHostViolation False",
};
Assert.Equal(expected.Length, ls.Length);
for (int i = 0; i < ls.Length; i++)
{
Assert.Equal(expected[i], ls[i]);
}
}
private async Task SaveWorkshiftDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultWorkShift(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <Workshift>(new BaseRecordManager <Workshift>(),
new WorkshiftValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task SaveMinimiumSalaryDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultMinimunSalaries(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <MinimunSalary>(new BaseRecordManager <MinimunSalary>(),
new MinimunSalaryValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task SaveIMSSWorkRiskDefaultAsync(InitializationParams initializationParams, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultIMSSWorkRisk(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <IMSSWorkRisk>(new BaseRecordManager <IMSSWorkRisk>(),
new IMSSWorkRiskValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task SaveSettlementCatalogDefaultAsync(InitializationParams initializationParams, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultSettlementCatalogTable(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <SettlementCatalog>(new BaseRecordManager <SettlementCatalog>(),
new SettlementCatalogValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task SaveAnualEmploymentSubsidyDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultAnualEmploymentSubsidy(companyID, instanceID, user);
var middlewareManager = new MiddlewareManager <AnualEmploymentSubsidy>(new BaseRecordManager <AnualEmploymentSubsidy>(),
new AnualEmploymentSubsidyValidator());
await middlewareManager.CreateAsync(result, companyID);
}
private async Task <List <IncidentType> > SaveIncidentTypeDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user, List <AccumulatedType> accumulatedTypes)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultIncidentType(companyID, instanceID, user, accumulatedTypes);
var middlewareManager = new MiddlewareManager <IncidentType>(new BaseRecordManager <IncidentType>(),
new IncidentTypeValidator());
await middlewareManager.CreateAsync(result, companyID);
return(result);
}
private static IEnumerable <string> serializeParams(InitializationParams init)
{
var cfg = init.ConfigurationPrototype;
var type = init.GetType();
foreach (var p in type.GetProperties())
{
if (!p.CanRead)
{
continue;
}
if (p.Name == "Parsers")
{
continue; // Will be checked later
}
if (p.Name == "ConfigurationPrototype")
{
continue; // Will be checked later
}
if (p.Name == "StorageEngine")
{
continue; // Will be checked later
}
string val = "";
if (p.PropertyType.IsInterface)
{
val = p.GetValue(init).GetType().FullName;
}
else
{
val = p.GetValue(init)?.ToString();
}
yield return($"{p.Name}: {val}");
}
yield return($"Parsers: {init.Parsers.Count()}");
for (int i = 0; i < init.Parsers.Count; i++)
{
yield return($"Parsers[{i}]: {init.Parsers[i]}");
}
type = cfg.GetType();
foreach (var p in type.GetProperties())
{
if (!p.CanRead)
{
continue;
}
var pVal = p.GetValue(cfg);
yield return($"Config.{p.Name} {pVal}");
}
}
public static void run()
{
var iP = new InitializationParams()
// Defines a Storage Engine
// All stored items will be in spider folder as JsonLines
.SetStorage(new Storage.JsonLinesStorage()); // JsonLines: https://jsonlines.org/
var spider = new SimpleSpider("BooksToScrape", new Uri("http://books.toscrape.com/"), iP);
// callback to gather items
spider.FetchCompleted += fetchCompleted_items;
// Ignore (cancel) the pages containing "/reviews/"
spider.ShouldFetch += (s, a) => { a.Cancel = a.Link.Uri.ToString().Contains("/reviews/"); };
// execute from first page
spider.Execute();
}
public static void run(SqliteDB database)
{
db = database;
db.CreateTables()
.Add <PessoalModel>()
.Add <Deputado>()
.Commit();
var init = InitializationParams.Default002()
.SetConfig(c => c.Disable_AutoAnchorsLinks()
.Set_DownloadDelay(0));
var spider = new SimpleSpider("camara_gabinete", new Uri("https://www.camara.leg.br/"), init);
spider.FetchCompleted += Spider_FetchCompleted;
spider.AddPage(new Uri("https://www.camara.leg.br/deputados/quem-sao"), spider.BaseUri);
spider.Execute();
}
public FieldsProcessor(
InitializationParams initializationParams,
IEnumerable <string> inputFieldNames,
IEnumerable <ExtensionInfo> extensions,
ITempFilesManager tempFilesManager)
{
if (inputFieldNames == null)
{
throw new ArgumentNullException(nameof(inputFieldNames));
}
initializationParams.InitializeInstance(this);
if (extensions != null)
{
this.extensions.AddRange(extensions);
}
this.inputFieldNames = inputFieldNames.Select((name, idx) => name ?? string.Format("Field{0}", idx)).ToList();
this.tempFilesManager = tempFilesManager;
}
private async Task SaveEmployerRegistrationAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
if (parameters.EmployerRegistration != null && parameters.EmployerRegistration.ID != Guid.Empty)
{
parameters.EmployerRegistration.CompanyID = companyID;
parameters.EmployerRegistration.InstanceID = instanceID;
parameters.EmployerRegistration.company = companyID;
parameters.EmployerRegistration.user = user;
parameters.EmployerRegistration.Name = parameters.EmployerRegistration.Code;
var result = new List <EmployerRegistration> {
parameters.EmployerRegistration
};
var middlewareManager = new MiddlewareManager <EmployerRegistration>(new BaseRecordManager <EmployerRegistration>(),
new EmployerRegistrationValidator());
await middlewareManager.CreateAsync(result, companyID);
}
}
private async Task <List <PeriodType> > SavePeriodTypeDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user)
{
var memoryTest = new MemoryStorageContext();
List <PeriodType> lstPeriodTypes = new List <PeriodType>();
//Quincenal
var forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.Biweekly;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.Biweekly,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate));
//Mensual
forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.Monthly;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.Monthly,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate));
//Semanal
forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.Weekly;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.Weekly,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate, parameters.PayrollCompanyConfiguration.WeeklySeventhDay));
//Extraordinario
forceUpdate = parameters.PayrollCompanyConfiguration.PaymentPeriodicity == PaymentPeriodicity.OtherPeriodicity;
lstPeriodTypes.AddRange(memoryTest.GetDefaultPeriodType(companyID, instanceID, user,
PaymentPeriodicity.OtherPeriodicity,
parameters.PayrollCompanyConfiguration.PaymentDays,
parameters.PayrollCompanyConfiguration.AdjustmentPay, forceUpdate));
var middlewareManager = new MiddlewareManager <PeriodType>(new BaseRecordManager <PeriodType>(),
new PeriodTypeValidator());
await middlewareManager.CreateAsync(lstPeriodTypes, companyID);
return(lstPeriodTypes);
}
public async Task <InitializationResult> InitializeAsync(string authTkn, Guid licenseServiceID, string socialReason,
string RFC, PayrollCompanyConfiguration payrollCompanyConfiguration, EmployerRegistration employerRegistration)
{
var createParmas = new InitializationParams()
{
AuthTkn = authTkn,
LicenseServiceID = licenseServiceID,
SocialReason = socialReason,
RFC = RFC,
PayrollCompanyConfiguration = payrollCompanyConfiguration,
EmployerRegistration = employerRegistration
};
string serializedResult = await ServiceHelperExtensions.CallRestServiceAsync(Format.JSON, RestMethod.POST, _authorizationHeader,
new Uri($"{_cotorraUri}"), new object[] { createParmas });
if (!String.IsNullOrEmpty(serializedResult))
{
return(JsonConvert.DeserializeObject <InitializationResult>(serializedResult));
}
return(default);
public static void run()
{
var init = new InitializationParams()
.SetCacher(new ContentCacher())
.SetDownloader(new WebClientDownloader())
// create a json parser for our QuotesObject class
.AddParser(new Parsers.JsonDeserializeParser <QuotesObject>(parsedResult_event)) // Received Json class
// Adds a SQLite storage to keep all collected quotes
.SetStorage(new Storage.SQLiteStorage <Quote>()) // Single quote class
.SetConfig(c => c.Enable_Caching()
.Disable_Cookies()
.Disable_AutoAnchorsLinks()
.Set_CachingNoLimit()
.Set_DownloadDelay(5000));
var spider = new SimpleSpider("QuotesToScrape", new Uri("http://quotes.toscrape.com/"), init);
// add first
spider.AddPage(buildPageUri(1), spider.BaseUri);
// execute
spider.Execute();
}
private async Task SavePeriodDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user,
List <PeriodType> periodTypes)
{
var memoryTest = new MemoryStorageContext();
var result = memoryTest.GetDefaultPeriod(companyID, instanceID, user,
parameters.PayrollCompanyConfiguration.PeriodInitialDate,
parameters.PayrollCompanyConfiguration.PeriodInitialDate.AddYears(1).Date,
parameters.PayrollCompanyConfiguration.CurrentExerciseYear,
periodTypes.FirstOrDefault(p => p.PaymentPeriodicity == parameters.PayrollCompanyConfiguration.PaymentPeriodicity));
result.AddRange(memoryTest.GetDefaultPeriod(companyID, instanceID, user,
parameters.PayrollCompanyConfiguration.PeriodInitialDate,
parameters.PayrollCompanyConfiguration.PeriodInitialDate.AddYears(1).Date,
parameters.PayrollCompanyConfiguration.CurrentExerciseYear,
periodTypes.FirstOrDefault(p => p.ExtraordinaryPeriod)));
var middlewareManager = new MiddlewareManager <Period>(new BaseRecordManager <Period>(),
new PeriodValidator());
await middlewareManager.CreateAsync(result, companyID);
}
public void Executar()
{
var init = InitializationParams
.Default002() // Usar configs padrão
.SetConfig(c => c.Set_DownloadDelay(000) // Aguardar 2s entre requisições
.Disable_AutoAnchorsLinks()); // Não sair navegando
var spider = new SimpleSpider("cota_camara", new Uri("https://www.camara.leg.br"), init);
spider.Configuration.SpiderAllowHostViolation = true; // Permite sair do domínio *.camara.leg.br
// Obter todos os palamentares
spider.AddPage(new Uri("https://www.camara.leg.br/cota-parlamentar/index.jsp"), spider.BaseUri);
// Obter páginas
spider.FetchCompleted += Spider_FetchCompleted;
spider.FetchFailed += spider_FetchFailed;
// Ignorar alguns endereços
spider.ShouldFetch += spider_ShouldFetch;
// mandar ver ...
spider.Execute();
}
public void InitializationParams_Default000()
{
int delay = 4321;
var init = InitializationParams.Default000(delay);
Assert.IsType <ContentCacher>(init.Cacher);
Assert.IsType <WebClientDownloader>(init.Downloader);
Assert.Empty(init.Parsers);
Assert.Null(init.StorageEngine);
Assert.Null(init.SpiderDirectory);
var cfg = init.ConfigurationPrototype;
Assert.False(cfg.Auto_RewriteRemoveFragment);
Assert.True(cfg.Cache_Enable);
Assert.Null(cfg.Cache_Lifetime);
Assert.Equal(delay, cfg.DownloadDelay);
Assert.False(cfg.Cookies_Enable);
Assert.False(cfg.Paused);
Assert.False(cfg.Paused_Cacher);
Assert.False(cfg.Paused_Downloader);
Assert.False(cfg.Auto_AnchorsLinks);
}
private async Task SaveConceptPaymentDefaultAsync(InitializationParams parameters, Guid companyID, Guid instanceID, Guid user, List <AccumulatedType> accumulatedTypes)
{
//Get Memory Default Data
var memoryTest = new MemoryStorageContext();
var resultTuple = memoryTest.GetDefaultConcept <ConceptPayment>(companyID, instanceID, user, accumulatedTypes);
//Results
var resultConcepts = resultTuple.Item1.Cast <ConceptPayment>().ToList();
var resultRelationship = resultTuple.Item2.ToList();
//middlewareManagers
var middlewareManager = new MiddlewareManager <ConceptPayment>(new BaseRecordManager <ConceptPayment>(),
new ConceptPaymentValidator());
var middlewareManagerConceptPaymentRelationship = new MiddlewareManager <ConceptPaymentRelationship>(new BaseRecordManager <ConceptPaymentRelationship>(),
new ConceptPaymentRelationshipValidator());
//Create ConceptPayment
await middlewareManager.CreateAsync(resultConcepts, companyID);
//Create ConceptPayment relationship with accumulates
await middlewareManagerConceptPaymentRelationship.CreateAsync(resultRelationship, companyID);
}
private async Task <(Guid, Guid, Guid, Guid)> CreateInstanceAsync(InitializationParams parameters,
Stack <Action> rollbackActions)
{
var companyID = Guid.Empty;
var instanceID = Guid.Empty;
var licenseID = Guid.Empty;
var licenseServiceID = Guid.Empty;
rollbackActions.Push(() => instanceClient.DeleteInstance(parameters.AuthTkn, instanceID));
var result = await instanceClient.CreateInstanceAsync(
parameters.AuthTkn,
parameters.LicenseServiceID,
parameters.RFC,
parameters.SocialReason);
companyID = result.CompanyID;
instanceID = result.InstanceID;
licenseID = result.LicenseID;
licenseServiceID = result.LicenseServiceID;
return(companyID, instanceID, licenseID, licenseServiceID);
}
public void InitializationParams_Default002()
{
int delay = 4321;
var init = InitializationParams.Default002(delay);
Assert.IsType <ContentCacher>(init.Cacher);
Assert.IsType <HttpClientDownloader>(init.Downloader); // Different from 001
Assert.NotEmpty((init.Downloader as HttpClientDownloader).IncludeRequestHeaders); // Different from 001 | Specific to HttpClientDownloader
Assert.Empty(init.Parsers);
Assert.Null(init.StorageEngine);
Assert.Null(init.SpiderDirectory);
var cfg = init.ConfigurationPrototype;
Assert.True(cfg.Auto_RewriteRemoveFragment); // Different from 001
Assert.True(cfg.Cache_Enable);
Assert.Null(cfg.Cache_Lifetime);
Assert.Equal(delay, cfg.DownloadDelay);
Assert.False(cfg.Cookies_Enable);
Assert.False(cfg.Paused);
Assert.False(cfg.Paused_Cacher);
Assert.False(cfg.Paused_Downloader);
Assert.True(cfg.Auto_AnchorsLinks);
}
public BigBang(InitializationParams initParams, InitializationMode initMode)
{
world = new World(initParams.worldSize);
this.initMode = initMode;
CreateCells(initParams.cellSpreadModifier);
}
public async Task <InitializationResult> InitializeAsync(InitializationParams parameters)
{
Stack <Action> rollbackActions = new Stack <Action>();
InitializationnValidator validator = new InitializationnValidator();
validator.BeforeProcess(parameters);
Guid companyID;
Guid instanceID;
Guid licenseID;
Guid licenseServiceID;
try
{
//Create company
var creationResult = await CreateInstanceAsync(parameters, rollbackActions);
companyID = creationResult.Item1;
instanceID = creationResult.Item2;
licenseID = creationResult.Item3;
licenseServiceID = creationResult.Item4;
parameters.PayrollCompanyConfiguration.company = companyID;
parameters.PayrollCompanyConfiguration.InstanceID = instanceID;
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
//PayrollConfiguration
await SavePayrollCompanyConfigurationAsync(parameters, companyID);
/***Initialize fares and tables catalogs***/
//MinimiumSalary
await SaveMinimiumSalaryDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//Benefit Type
await SaveBenefitTypeDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//IncomeTax
await SaveMonthlyIncomeTaxDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//AnualIncomeTax
await SaveAnualIncomeTaxDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//Employment monthly subsidy
await SaveMonthlyEmploymentSubsidyDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//Employment anual subsidy
await SaveAnualEmploymentSubsidyDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//IMSS
await SaveIMSSFareDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//SGDFlimits
await SaveSGDFLimitsDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//IMSSEmployeeTable
await SaveIMSSEmployeeTableDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//IMSSEmployerTable
await SaveIMSSEmployerTableDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//IMSSWorkRisk
await SaveIMSSWorkRiskDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//UMA
await SaveUMADefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//SettlementCatalog
await SaveSettlementCatalogDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//WorkShift
await SaveWorkshiftDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//AccumulatedType
var accumulated = await SaveAccumulatedTypeDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//Concepts (Salary. Liability, Deduction)
await SaveConceptPaymentDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user, accumulated);
//Employer Registration
await SaveEmployerRegistrationAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//IncidentType
var incidentTypes = await SaveIncidentTypeDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user, accumulated);
//Incident Type Relationship
await SaveIncidentTypeRelationshipDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user, incidentTypes);
//Period Type
var periodTypes = await SavePeriodTypeDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user);
//Period
await SavePeriodDefaultAsync(parameters, companyID, instanceID, parameters.PayrollCompanyConfiguration.user, periodTypes);
scope.Complete();
}
}
catch (Exception ex)
{
rollbackActions.DoRollBack();
if (ex is CotorraException)
{
throw new CotorraException(0001, "Create Company", ex.Message, ex);
}
else
{
throw new CotorraException(0002, "Create Company", "Ocurrio un error al crear la compañía por favor vuelve a intentarlo en unos minutos.",
ex);
}
}
return(new InitializationResult()
{
CompanyID = companyID,
InstanceID = instanceID,
LicenseID = licenseID,
LicenseServiceID = licenseServiceID
});
}
