public JsonResult IsTenantAvailable(TenantModel tenant)
{
try
{
var svc = WebServiceFactory.ApplicationTenant();
var result = svc.ReadMultiple(new []
{
new ApplicationTenant_Filter
{
Field = ApplicationTenant_Fields.Name,
Criteria = "@" + tenant.TenantName
},
new ApplicationTenant_Filter
{
Field = ApplicationTenant_Fields.Application_Service_Name_Web_Service_Filter_Field,
Criteria = Configuration.ApplicationServiceName
}
}, null, 1);
return(Json(result.Length == 0, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(e.Message, JsonRequestBehavior.AllowGet));
}
}
private void _cheat_in_place_of_sign_in()
{
if (State.Get <TenantModel>() == null)
{
var svc = WebServiceFactory.ApplicationTenant();
State.Set(svc.ReadMultiple(new[]
{
new ApplicationTenant.ApplicationTenant_Filter
{
Field = ApplicationTenant.ApplicationTenant_Fields.Name,
Criteria = "Gesellschaft GmbH"
}
}, null, 0).FirstOrDefault()?.ToTenantModel());
State.Set(new UserModel
{
UserName = "******",
Password = "******"
});
}
}
protected override void RequestTasks()
{
var svcAppTenantCompany = WebServiceFactory.ApplicationTenantCompany();
ApplicationTenantCompany.ApplicationTenantCompany company = null;
RegisterTask(
new AsyncWorkflowTask("Waiting for company provisioning to complete", (state, action) =>
{
Task.Factory.StartNew(() =>
{
try
{
var attempts = 0;
var svcTenant = WebServiceFactory.ApplicationTenant();
while (company == null)
{
var tenant = svcTenant.Read(state.Get <TenantModel>().Id);
company = svcAppTenantCompany.Read(tenant.ID, Configuration.DefaultCompanyName);
if (company == null)
{
Thread.Sleep(5000);
}
if (attempts++ > 60)
{
throw new Exception(
"Timeout during company provisioning. Please contact Contoso support department.");
}
}
action.Complete();
}
catch (Exception e)
{
action.Fail(e);
}
});
}).Then(
new AsyncWorkflowTask("Renaming company", (state, action) =>
{
svcAppTenantCompany.SetNameCompleted += (sender, args) =>
{
action.CompleteAsyncOperation(args, () =>
{
state["CompanyRenamed"] = true;
});
};
svcAppTenantCompany.SetNameAsync(company?.Key, state.Get <TenantModel>().CompanyName);
}).Then(
new AsyncWorkflowTask("Waiting for user account provisioning", (state, task) =>
{
Task.Factory.StartNew(() =>
{
while (!state["UserCreated"])
{
Thread.Sleep(1000);
}
task.Complete();
});
})
.Then(
new List <ITask>
{
new AsyncWorkflowTask("Configuring company", (state, action) =>
{
var features = state.Get <FeaturesModel>();
var tenant = state.Get <TenantModel>();
var svcCompanyInfo = WebServiceFactory.Tenant.CompanyInformation(state);
var companyInfo = svcCompanyInfo.ReadMultiple(null, null, 0)[0];
companyInfo.Name = tenant.CompanyName;
companyInfo.Address = features.CompanyAddress;
companyInfo.Address_2 = features.CompanyAddress2;
companyInfo.Post_Code = features.CompanyPostCode;
companyInfo.City = features.CompanyCity;
companyInfo.Country_Region_Code = features.CompanyCountryCode;
companyInfo.Ship_to_Name = tenant.CompanyName;
companyInfo.Ship_to_Address = features.CompanyAddress;
companyInfo.Ship_to_Address_2 = features.CompanyAddress2;
companyInfo.Ship_to_Post_Code = features.CompanyPostCode;
companyInfo.Ship_to_City = features.CompanyCity;
companyInfo.Ship_to_Country_Region_Code = features.CompanyCountryCode;
companyInfo.VAT_Registration_No = features.VatRegistrationNumber;
svcCompanyInfo.UpdateCompleted += (sender, args) =>
{
action.CompleteAsyncOperation(args, null);
};
svcCompanyInfo.UpdateAsync(companyInfo);
}),
new AsyncWorkflowTask("Configuring G/L", (state, action) =>
{
var glSvc = WebServiceFactory.Tenant.GeneralLedgerSetup(state);
var glSetup = glSvc.ReadMultiple(null, null, 0)[0];
var features = state.Get <FeaturesModel>();
glSetup.LCY_Code = features.LocalCurrencyCode;
glSetup.Register_Time = features.RegisterTime;
glSvc.UpdateCompleted += (sender, args) =>
{
action.CompleteAsyncOperation(args, null);
};
glSvc.UpdateAsync(glSetup);
})
})
)
)
);
}
protected override void RequestTasks()
{
var service = WebServiceFactory.ApplicationTenant();
RegisterTask(
new AsyncWorkflowTask("Creating a new tenant", (state, task) =>
{
service.CreateCompleted += (sender, args) =>
{
task.CompleteAsyncOperation(args, () => state.Set(args.ApplicationTenant));
};
service.CreateAsync(state.Get <TenantModel>().ToApplicationTenant());
})
.Then(
new AsyncWorkflowTask("Starting provisioning a new Microsoft Dynamics NAV tenant",
(state, task) =>
{
service.BeginProvisionCompleted += (sender, args) =>
{
task.CompleteAsyncOperation(args, () => _operationId = args.Result);
};
service.BeginProvisionAsync(state.Get <ApplicationTenant.ApplicationTenant>().Key);
})
.Then(
new AsyncWorkflowTask(
"Waiting for provisioning a new Microsoft Dynamics NAV tenant to complete",
(state, task) =>
{
Task.Factory.StartNew(() =>
{
var status = @"provisioning";
var errorCount = 0;
while (status == "provisioning")
{
try
{
status = _operation.GetOperationStatus(_operationId).ToLower();
Thread.Sleep(5000);
}
catch (Exception e)
{
if (errorCount++ > 5)
{
task.Fail(e);
return;
}
}
}
task.Complete();
});
})
.Then(
new AsyncWorkflowTask("Retrieving provisioned tenant information",
(state, task) =>
{
service.ReadCompleted += (sender, args) =>
{
task.CompleteAsyncOperation(args, () =>
{
state.Set(args.Result);
state.Get <TenantModel>().Id = args.Result.ID;
state.Get <TenantModel>().Url = args.Result.URL;
switch (args.Result.Provisioning_Status)
{
case Provisioning_Status.Active:
task.Complete();
break;
case Provisioning_Status.Provisioning_Failed:
task.Fail(
new Exception(
$"Provisioning of tenant {args.Result.Name} failed."));
break;
}
});
};
service.ReadAsync(state.Get <ApplicationTenant.ApplicationTenant>().ID);
})
))));
}
