public IActionResult GetServicePlan()
{
List <ServicePlan> PlanList = new List <ServicePlan>();
try
{
DataTable dt = Data.ServiceAvailability.GetServicePlan();
if (dt.Rows.Count > 0)
{
for (int i = 0; i < dt.Rows.Count; i++)
{
ServicePlan service = new ServicePlan();
service.ServicePlanID = (int)dt.Rows[i]["ServicePlanID"];
service.PlanType = dt.Rows[i]["PlanType"].ToString();
service.IsOfferPlan = (bool)dt.Rows[i]["IsOfferPlan"];
PlanList.Add(service);
}
return(StatusCode((int)HttpStatusCode.OK, PlanList));
}
else
{
return(StatusCode((int)HttpStatusCode.OK, new { }));
}
}
catch (Exception e)
{
string SaveErrorLog = Data.Common.SaveErrorLog("GetServicePlan", e.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError, new { error = new { message = e.Message } }));
}
}
public JsonResult Update(ServicePlan servicePlan)
{
using (var ServicePlanRepository = _factory.GetRepository <ServicePlan>())
{
return(Json(ServicePlanRepository.Update(servicePlan)));
}
}
public bool Delete(ServicePlan servicePlan)
{
using (var ServicePlanRepository = _factory.GetRepository <ServicePlan>())
{
return(ServicePlanRepository.Delete(servicePlan));
}
}
//Thêm gói cước
public JsonResultModel AddServicePlan(ListServicePlanOutputModel dt)
{
try
{
ServicePlan check = cnn.ServicePlans.Where(sv => sv.IsActive.Equals(SystemParam.ACTIVE) && sv.Name.Equals(dt.Name) && sv.CategoryID.Equals(dt.CateID)).FirstOrDefault();
if (check != null)
{
return(rp.response(SystemParam.ERROR, SystemParam.CODE_EXISTING, SystemParam.ERROR_MESSAGE_SERVICE_PLAN_EXISTING, ""));
}
ServicePlan s = new ServicePlan();
s.Name = dt.Name;
s.Status = dt.Status;
s.Price = dt.Price;
s.IsActive = SystemParam.ACTIVE;
s.CreatedDate = DateTime.Now;
s.Description = dt.Descreiption;
s.ImageUrl = dt.ImageUrl;
s.CategoryID = dt.CateID;
s.Value = dt.Value;
cnn.ServicePlans.Add(s);
cnn.SaveChanges();
return(rp.response(SystemParam.SUCCESS, SystemParam.SUCCESS_CODE, SystemParam.SUCCESS_MESSAGE, ""));
}
catch
{
return(rp.serverError());
}
}
/// <summary>
/// Modify the backup service plan.
/// </summary>
/// <param name="client">
/// The <see cref="ComputeApiClient"/> object
/// </param>
/// <param name="serverId">
/// The server id
/// </param>
/// <param name="plan">
/// The plan to change to
/// </param>
/// <returns>
/// The status of the request
/// </returns>
public static async Task<Status> ChangeBackupPlan(this IComputeApiClient client, string serverId, ServicePlan plan)
{
return
await
client.WebApi.ApiPostAsync<ModifyBackup, Status>(
ApiUris.ChangeBackupPlan(client.Account.OrganizationId, serverId),
new ModifyBackup {servicePlan = plan});
}
/// <summary>
/// Enables the backup with a specific service plan.
/// </summary>
/// <param name="client">
/// The <see cref="ComputeApiClient"/> object
/// </param>
/// <param name="serverId">
/// The server id
/// </param>
/// <param name="plan">
/// The enumerated service plan
/// </param>
/// <returns>
/// The status of the request
/// </returns>
public static async Task<Status> EnableBackup(this IComputeApiClient client, string serverId, ServicePlan plan)
{
return
await
client.WebApi.ApiPostAsync<NewBackup, Status>(
ApiUris.EnableBackup(client.Account.OrganizationId, serverId),
new NewBackup {servicePlan = plan});
}
public ActionResult DeleteConfirmed(string id)
{
ServicePlan servicePlan = db.ServicePlans.Find(id);
db.ServicePlans.Remove(servicePlan);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ServicePlan GetServicePlanSettings(string servicePlanName)
{
string filePath = Path.Combine(ServicePlanConfiguration.servicePlansFolder, servicePlanName + ".servicePlan");
ServicePlan servicePlan = ServicePlan.LoadFromFile(filePath);
servicePlan.Name = servicePlanName;
return(servicePlan);
}
internal void FixDependencies(ServicePlan sp)
{
foreach (DependencyEntry dependencyEntry in this.dependencies)
{
if (dependencyEntry.GetFeatureValue() && !dependencyEntry.GetDependencyValue(sp))
{
dependencyEntry.SetDependencyValue(sp, true);
}
}
}
public ActionResult Edit([Bind(Include = "Id,UserName,Nazwa,PoczątekSłużby,ZakończenieSłużby,StartSłużby,KoniecSłużby,Obsługa,UwagiDyspozytora")] ServicePlan servicePlan)
{
if (ModelState.IsValid)
{
db.Entry(servicePlan).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(servicePlan));
}
/// <summary>
/// The enable backup.
/// </summary>
/// <param name="serverId">
/// The server id.
/// </param>
/// <param name="plan">
/// The plan.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <Status> EnableBackup(string serverId, ServicePlan plan)
{
return
(await
_apiClient.PostAsync <NewBackup, Status>(
ApiUris.EnableBackup(_apiClient.OrganizationId, serverId),
new NewBackup
{
servicePlan = plan
}));
}
/// <summary>
/// The enable backup.
/// </summary>
/// <param name="serverId">
/// The server id.
/// </param>
/// <param name="plan">
/// The plan.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task<Status> EnableBackup(string serverId, ServicePlan plan)
{
return
await
_apiClient.PostAsync<NewBackup, Status>(
ApiUris.EnableBackup(_apiClient.OrganizationId, serverId),
new NewBackup
{
servicePlan = plan
});
}
/// <summary>
/// The change backup plan.
/// </summary>
/// <param name="serverId">
/// The server id.
/// </param>
/// <param name="plan">
/// The plan.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task<Status> ChangeBackupPlan(string serverId, ServicePlan plan)
{
return
await
_apiClient.PostAsync<ModifyBackup, Status>(
ApiUris.ChangeBackupPlan(_apiClient.OrganizationId, serverId),
new ModifyBackup
{
servicePlan = plan
});
}
/// <summary>
/// The change backup plan.
/// </summary>
/// <param name="serverId">
/// The server id.
/// </param>
/// <param name="plan">
/// The plan.
/// </param>
/// <returns>
/// The <see cref="Task"/>.
/// </returns>
public async Task <Status> ChangeBackupPlan(string serverId, ServicePlan plan)
{
return
(await
_apiClient.PostAsync <ModifyBackup, Status>(
ApiUris.ChangeBackupPlan(_apiClient.OrganizationId, serverId),
new ModifyBackup
{
servicePlan = plan
}));
}
public static ServicePlan CreateServicePlan(int ID, byte[] rowVersion, bool internationalDialing, string voicePlan, string dataPlan, bool hotSpot)
{
ServicePlan servicePlan = new ServicePlan();
servicePlan.Id = ID;
servicePlan.RowVersion = rowVersion;
servicePlan.InternationalDialing = internationalDialing;
servicePlan.VoicePlan = voicePlan;
servicePlan.DataPlan = dataPlan;
servicePlan.HotSpot = hotSpot;
return(servicePlan);
}
public ActionResult Create([Bind(Include = "Id,UserName,Nazwa,NumerSkładu,SeriaPociągu,NumerPociągu,UwagiDyspozytora")] ServicePlan servicePlan)
{
if (ModelState.IsValid)
{
MasterProjectContext db = new MasterProjectContext();
db.ServicePlans.Add(servicePlan);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(servicePlan));
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
bool advancedHydrateableObjectsSharedEnabled = this.newServicePlanSettings.Organization.AdvancedHydrateableObjectsSharedEnabled;
base.InternalCreateSharedConfiguration = (this.oldServicePlanSettings.Organization.ShareableConfigurationEnabled && this.newServicePlanSettings.Organization.ShareableConfigurationEnabled && this.tenantCU.SupportedSharedConfigurations.Count == 0);
base.InternalIsSharedConfigServicePlan = this.config.IsSharedConfigurationAllowedForServicePlan(this.newServicePlanSettings);
this.monadConnection.RunspaceProxy.SetVariable("TargetServicePlan", this.newServicePlan);
this.monadConnection.RunspaceProxy.SetVariable("TargetProgramId", this.targetProgramId);
this.monadConnection.RunspaceProxy.SetVariable("TargetOfferId", this.targetOfferId);
if (this.tenantCU.ServicePlan == this.newServicePlan)
{
base.WriteVerbose(Strings.VerboseWillSkipUpdateServicePlan(this.Identity.ToString()));
}
else if (!ServicePlan.CompareAndCalculateDelta(this.oldServicePlanSettings, this.newServicePlanSettings, this.IsCrossSKUMigration, out this.deltaServicePlanSettings, out this.featuresToApply))
{
base.WriteVerbose(Strings.VerboseWillUpgradeServicePlan(this.Identity.ToString(), this.tenantCU.ServicePlan, this.newServicePlan));
if (advancedHydrateableObjectsSharedEnabled)
{
string text;
if (!this.config.TryGetHydratedOfferId(this.targetProgramId, this.targetOfferId, out text))
{
text = this.targetOfferId;
}
SharedConfigurationInfo sharedConfigurationInfo = SharedConfigurationInfo.FromInstalledVersion(this.targetProgramId, text);
OrganizationId organizationId = SharedConfiguration.FindOneSharedConfigurationId(sharedConfigurationInfo, this.tenantCU.OrganizationId.PartitionId);
if (organizationId == null)
{
base.WriteError(new SharedConfigurationValidationException(Strings.ErrorSharedConfigurationNotFound(this.targetProgramId, text, sharedConfigurationInfo.CurrentVersion.ToString())), (ErrorCategory)1000, null);
}
else
{
this.monadConnection.RunspaceProxy.SetVariable("TargetSharedConfiguration", organizationId.OrganizationalUnit.Name);
}
}
if (ManageServicePlanMigrationBase.MailboxPlanConfigurationChanged(this.deltaServicePlanSettings))
{
ManageServicePlanMigrationBase.CopyEnabledMailboxPlanRoleAssignmentFeatures(this.deltaServicePlanSettings, this.newServicePlanSettings);
}
this.newServicePlanSettings.Name = "new";
base.InternalProcessRecord();
if (this.configOnly)
{
this.WriteWarning(Strings.WarningUpgradeIsNotComplete(this.UpgradePhase.ToString()));
}
}
else
{
base.WriteVerbose(Strings.VerboseWillSkipUpdateServicePlan(this.Identity.ToString()));
}
TaskLogger.LogExit();
}
private IQueryable <ServicePlan> GetAllTest()
{
var list = new List <ServicePlan>();
ServicePlan a1 = new ServicePlan {
Id = 1
};
ServicePlan a2 = new ServicePlan {
Id = 2
};
list.Add(a1);
list.Add(a2);
return(list.AsQueryable());
}
public ActionResult Edit(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ServicePlan servicePlan = db.ServicePlans.Find(id);
if (servicePlan == null)
{
return(HttpNotFound());
}
return(View(servicePlan));
}
//Xóa gói cước
public JsonResultModel DelSercicePlan(int id)
{
try
{
ServicePlan s = cnn.ServicePlans.Find(id);
s.IsActive = SystemParam.NO_ACTIVE;
cnn.SaveChanges();
return(rp.response(SystemParam.SUCCESS, SystemParam.SUCCESS_CODE, SystemParam.SUCCESS_MESSAGE, ""));
}
catch
{
return(rp.serverError());
}
}
public void Create2()
{
ServicePlan servicePlan = new ServicePlan()
{
Id = 1
};
var mock = new Mock <IRepository <ServicePlan> >();
mock.Setup(repo => repo.Create(servicePlan));
var factoryMock = new Mock <IRepositoryFactory>();
factoryMock.Setup(f => f.GetRepository <ServicePlan>()).Returns(mock.Object);
_servicePlanController = new ServicePlanController(factoryMock.Object);
//Assert.AreEqual(servicePlan, factoryMock);
}
internal List <ValidationError> ValidateDependencies(ServicePlan sp)
{
List <ValidationError> list = new List <ValidationError>();
foreach (DependencyEntry dependencyEntry in this.dependencies)
{
bool flag = dependencyEntry.GetDependencyValue(sp);
bool flag2 = dependencyEntry.GetFeatureValue();
if (flag2 && !flag)
{
list.Add(new DependencyValidationError(dependencyEntry.FeatureName, flag2, dependencyEntry.DependencyFeatureName, flag));
}
}
return(list);
}
public bool Update(ServicePlan servicePlan)
{
var fetchedServiceplan = GetServiceplan(servicePlan.ServicePlanId);
if (fetchedServiceplan != null)
{
fetchedServiceplan.Amount = servicePlan.Amount;
fetchedServiceplan.NoOfWashes = servicePlan.NoOfWashes;
fetchedServiceplan.PlanName = servicePlan.PlanName;
fetchedServiceplan.ValidityDate = servicePlan.ValidityDate;
_context.SaveChanges();
return(true);
}
return(false);
}
internal static void CopyEnabledMailboxPlanRoleAssignmentFeatures(ServicePlan deltaServicePlan, ServicePlan toServicePlan)
{
for (int i = 0; i < deltaServicePlan.MailboxPlans.Count; i++)
{
ServicePlan.MailboxPlan mailboxPlan = deltaServicePlan.MailboxPlans[i];
foreach (object obj in ((IEnumerable)mailboxPlan.Schema))
{
FeatureDefinition featureDefinition = (FeatureDefinition)obj;
if (featureDefinition.Categories.Contains(FeatureCategory.MailboxPlanRoleAssignment) && (bool)toServicePlan.GetMailboxPlanByName(mailboxPlan.Name)[featureDefinition])
{
mailboxPlan[featureDefinition] = true;
}
}
}
}
public void Create()
{
var memoryStore = new List <ServicePlan>();
ServicePlan servicePlanStub = new ServicePlan {
Id = 1
};
var mock = new Mock <IRepository <ServicePlan> >();
mock.Setup(repo => repo.GetAll()).Returns(memoryStore.AsQueryable());
mock.Setup(repo => repo.Create(It.IsAny <ServicePlan>())).Returns((ServicePlan servicePlan) => {
servicePlan.Id = 1;
memoryStore.Add(servicePlan);
return(servicePlan);
});
var factoryMock = new Mock <IRepositoryFactory>();
factoryMock.Setup(f => f.GetRepository <ServicePlan>()).Returns(mock.Object);
_servicePlanController = new ServicePlanController(factoryMock.Object);
var emptyJson = _servicePlanController.GetAll();
Assert.IsNotNull(emptyJson);
var emptyStore = emptyJson.Value as List <ServicePlan>;
Assert.IsNotNull(emptyStore);
Assert.AreEqual(emptyStore.Count, 0);
var json = _servicePlanController.Create(servicePlanStub);
Assert.IsNotNull(json);
var result = json.Value as ServicePlan;
Assert.NotNull(result);
Assert.AreEqual(result.Id, 1);
Assert.AreEqual(result.ServicePlanName, servicePlanStub.ServicePlanName);
var notEmptyJson = _servicePlanController.GetAll();
Assert.IsNotNull(notEmptyJson);
var notEmptyStore = notEmptyJson.Value as List <ServicePlan>;
Assert.IsNotNull(notEmptyStore);
Assert.AreEqual(notEmptyStore.Count, 1);
}
protected override void InternalValidate()
{
base.InternalValidate();
if (!this.tenantCU.IsUpgradingOrganization)
{
base.WriteError(new OrganizationUpgradeException(Strings.ErrorOrganizationIsNotInUpgradeState), ExchangeErrorCategory.Client, base.Identity);
}
ServicePlan servicePlanSettings = ServicePlanConfiguration.GetInstance().GetServicePlanSettings(this.tenantCU.ProgramId, this.tenantCU.OfferId);
base.InternalIsSharedConfigServicePlan = ServicePlanConfiguration.GetInstance().IsSharedConfigurationAllowedForServicePlan(servicePlanSettings);
base.InternalLocalStaticConfigEnabled = !servicePlanSettings.Organization.AdvancedHydrateableObjectsSharedEnabled;
base.InternalLocalHydrateableConfigEnabled = !servicePlanSettings.Organization.CommonHydrateableObjectsSharedEnabled;
if (base.InternalIsSharedConfigServicePlan)
{
if (this.tenantCU.SharedConfigurationInfo != null)
{
base.WriteError(new SharedConfigurationValidationException(Strings.ErrorSharedConfigurationUpgradeNotSupported), ExchangeErrorCategory.Client, base.Identity);
return;
}
base.InternalCreateSharedConfiguration = false;
}
}
//Đăng ký dịch vụ
public JsonResultModel CreateOrder(OrderInputModel input)
{
try
{
//Kiểm tra token
Customer cus = cnn.Customers.Where(c => c.IsActive.Equals(SystemParam.ACTIVE) && c.Token.Equals(input.token)).FirstOrDefault();
if (cus == null)
{
return(rp.response(SystemParam.ERROR, SystemParam.FAIL, SystemParam.TOKEN_NOT_FOUND, ""));
}
ServicePlan s = cnn.ServicePlans.Find(input.ServiceID);
Order o = new Order();
Random rd = new Random();
string code = s.Category.Type + rd.Next(10000, 99999) + rd.Next(10000, 99999);
o.Code = code;
o.CustomerID = cus.ID;
o.ProvinceID = input.ProvinceID;
o.DistrictID = input.DistrictID;
o.VillageID = input.VillageID;
o.TotalPrice = s.Price;
o.Discount = s.Price;
o.CreatedDate = DateTime.Now;
o.ServicePlanID = s.ID;
o.Status = SystemParam.PENDING;
o.Note = input.Note;
o.IsActive = SystemParam.ACTIVE;
o.Address = input.Address;
cnn.Orders.Add(o);
cnn.SaveChanges();
return(rp.response(SystemParam.SUCCESS, SystemParam.SUCCESS_CODE, SystemParam.SUCCESS_MESSAGE, ""));
}
catch (Exception e)
{
e.ToString();
return(rp.serverError());
}
}
private static bool FeaturesChanged(ServicePlan deltaServicePlan, FeatureCategory featureCategory)
{
foreach (object obj in ((IEnumerable)deltaServicePlan.Organization.Schema))
{
FeatureDefinition featureDefinition = (FeatureDefinition)obj;
if (featureDefinition.Categories.Contains(featureCategory) && deltaServicePlan.Organization.PropertyBag.IsModified(featureDefinition))
{
return(true);
}
}
for (int i = 0; i < deltaServicePlan.MailboxPlans.Count; i++)
{
foreach (object obj2 in ((IEnumerable)deltaServicePlan.MailboxPlans[i].Schema))
{
FeatureDefinition featureDefinition2 = (FeatureDefinition)obj2;
if (featureDefinition2.Categories.Contains(featureCategory) && deltaServicePlan.MailboxPlans[i].PropertyBag.IsModified(featureDefinition2))
{
return(true);
}
}
}
return(false);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
Profile profile = new Profile {
UserName = model.Email, Imię = model.Imię, Nazwisko = model.Nazwisko, Miasto = model.Miasto, Zakład = model.Zakład
};
ServicePlan servicePlan = new ServicePlan {
UserName = model.Email
};
MasterProjectContext db = new MasterProjectContext();
db.Profiles.Add(profile);
db.SaveChanges();
// Aby uzyskać więcej informacji o sposobie włączania potwierdzania konta i resetowaniu hasła, odwiedź stronę https://go.microsoft.com/fwlink/?LinkID=320771
// Wyślij wiadomość e-mail z tym łączem
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Potwierdź konto", "Potwierdź konto, klikając <a href=\"" + callbackUrl + "\">tutaj</a>");
return(RedirectToAction("Login", "Account"));
}
AddErrors(result);
}
// Dotarcie do tego miejsca wskazuje, że wystąpił błąd, wyświetl ponownie formularz
return(View(model));
}
public void AddToServicePlans(ServicePlan servicePlan)
{
base.AddObject("ServicePlans", servicePlan);
}
private static ServicePlan Compile(Dictionary <MethodInfo, MethodCallExpression> expressions, object serviceObject)
{
// step: collect all types, methods, variables referenced in this expression
var workerQueue = new Queue <KeyValuePair <MethodInfo, MethodCallExpression> >();
foreach (var exp in expressions)
{
workerQueue.Enqueue(new KeyValuePair <MethodInfo, MethodCallExpression>(exp.Key, exp.Value));
}
var contexts = new Dictionary <MethodInfo, QueryContext>();
while (workerQueue.Count > 0)
{
var exp = workerQueue.Dequeue();
var context = new QueryContext(serviceObject, exp.Value, exp.Key.Name);
context.Collect();
contexts.Add(exp.Key, context);
foreach (var s in context.ExternalComposedSerivce.Where(s => !contexts.ContainsKey(s.Key)))
{
workerQueue.Enqueue(new KeyValuePair <MethodInfo, MethodCallExpression>(s.Key, s.Value));
}
}
// step: prepare service plan
var codeGenerator = new CodeGenerator();
var name = serviceObject.GetType().Name + "." + codeGenerator.AppId;
var plan = new ServicePlan
{
DependentServices = contexts
.SelectMany(c => c.Value.Services.Select(r => r.Value))
.DistinctBy(s => s.Url)
.ToArray(),
Package = new ServicePackage()
};
SystemHelper.CreateOrCleanDirectory(name);
// step: generate composed service code
var sources = new HashSet <string>();
var libs = new HashSet <string>();
var dir = name + ".Source";
SystemHelper.CreateOrCleanDirectory(dir);
libs.Add(Path.Combine(Environment.GetEnvironmentVariable("DSN_ROOT"), "lib", "dsn.dev.csharp.dll"));
libs.Add(Path.Combine(Environment.GetEnvironmentVariable("DSN_ROOT"), "lib", "Thrift.dll"));
var code = codeGenerator.BuildRdsn(serviceObject.GetType(), contexts.Select(c => c.Value).ToArray());
SystemHelper.StringToFile(code, Path.Combine(dir, name + ".cs"));
sources.Add(Path.Combine(dir, name + ".cs"));
libs.UnionWith(QueryContext.KnownLibs);
// step: generate client code for all dependent services
foreach (var s in contexts
.SelectMany(c => c.Value.Services.Select(r => r.Value))
.DistinctBy(s => s.PackageName)
.Select(s => s.ExtractSpec()))
{
var provider = SpecProviderManager.Instance().GetProvider(s.SType);
Trace.Assert(null != provider, "Language provider missing for type " + s.SType);
LinkageInfo linkInfo;
var err = provider.GenerateServiceClient(s, dir, ClientLanguage.Client_CSharp, ClientPlatform.Windows, out linkInfo);
Trace.Assert(FlowErrorCode.Success == err);
sources.UnionWith(linkInfo.Sources);
libs.UnionWith(linkInfo.DynamicLibraries);
}
// step: fill service plan
plan.Package.Spec = new ServiceSpec
{
SType = ServiceSpecType.Thrift,
MainSpecFile = serviceObject.GetType().Name + ".thrift",
ReferencedSpecFiles = plan.DependentServices
.DistinctBy(s => s.PackageName)
.Where(s => s.Spec.SType == ServiceSpecType.Thrift)
.SelectMany(s =>
{
var spec = s.ExtractSpec();
var specFiles = new List <string> {
spec.MainSpecFile
};
SystemHelper.SafeCopy(Path.Combine(spec.Directory, spec.MainSpecFile),
Path.Combine(name, spec.MainSpecFile), false);
foreach (var ds in spec.ReferencedSpecFiles)
{
specFiles.Add(ds);
SystemHelper.SafeCopy(Path.Combine(spec.Directory, ds), Path.Combine(name, ds), false);
}
return(specFiles);
}
)
.Distinct()
.ToList(),
Directory = name
};
plan.Package.MainSpec = ServiceContract.GenerateStandAloneThriftSpec(serviceObject.GetType(), plan.Package.Spec.ReferencedSpecFiles);
SystemHelper.StringToFile(plan.Package.MainSpec, Path.Combine(name, plan.Package.Spec.MainSpecFile));
if (SystemHelper.RunProcess("php.exe", Path.Combine(Environment.GetEnvironmentVariable("DSN_ROOT"), "bin", "dsn.generate_code.php") + " " + Path.Combine(name, plan.Package.Spec.MainSpecFile) + " csharp " + dir + " json layer3") == 0)
{
sources.Add(Path.Combine(dir, serviceObject.GetType().Name + ".client.cs"));
sources.Add(Path.Combine(dir, serviceObject.GetType().Name + ".server.cs"));
sources.Add(Path.Combine(dir, "ThriftJsonHelper.cs"));
sources.Add(Path.Combine(dir, serviceObject.GetType().Name + ".main.composed.cs"));
sources.Add(Path.Combine(dir, serviceObject.GetType().Name + ".code.definition.cs"));
}
else
{
Console.Write("php codegen failed");
}
//grab thrift-generated files
sources.UnionWith(Directory.GetFiles(Path.Combine(dir, "thrift"), "*.cs", SearchOption.AllDirectories));
// step: generate composed service package
CSharpCompiler.ToDiskAssembly(sources.ToArray(), libs.ToArray(), new string[] { },
Path.Combine(name, name + ".exe"),
true,
true
);
libs.Add(Path.Combine(Environment.GetEnvironmentVariable("DSN_ROOT"), "lib", "dsn.core.dll"));
libs.Add(Path.Combine(Environment.GetEnvironmentVariable("DSN_ROOT"), "lib", "zookeeper_mt.dll"));
foreach (var lib in libs.Where(lib => !lib.StartsWith("System.")))
{
SystemHelper.SafeCopy(lib, Path.Combine(name, Path.GetFileName(lib)), false);
}
//Console.ReadKey();
return(plan);
}
public static ServicePlan CreateServicePlan(int ID, byte[] rowVersion, bool internationalDialing, string voicePlan, string dataPlan, bool hotSpot)
{
ServicePlan servicePlan = new ServicePlan();
servicePlan.Id = ID;
servicePlan.RowVersion = rowVersion;
servicePlan.InternationalDialing = internationalDialing;
servicePlan.VoicePlan = voicePlan;
servicePlan.DataPlan = dataPlan;
servicePlan.HotSpot = hotSpot;
return servicePlan;
}
public static async Task<Status> ChangeBackupPlan(this IComputeApiClient client, string serverId, ServicePlan plan)
{
return await client.Backup.ChangeBackupPlan(serverId, plan);
}
public static async Task <Status> ChangeBackupPlan(this IComputeApiClient client, string serverId, ServicePlan plan)
{
return(await client.Backup.ChangeBackupPlan(serverId, plan));
}
private void UpdateRolesInOrg(RoleNameMappingCollection mapping, RoleDefinition[] roleDefinitions, ServicePlan servicePlan)
{
TaskLogger.LogEnter();
Container container = this.configurationSession.Read <Container>(this.rolesContainerId);
if (container == null)
{
base.WriteError(new ContainerNotFoundException(this.rolesContainerId.DistinguishedName), ErrorCategory.ObjectNotFound, null);
}
base.LogReadObject(container);
List <RoleDefinition> list = new List <RoleDefinition>();
RoleUpgradeConfigurationSettings settings = new RoleUpgradeConfigurationSettings
{
AvailableRoleEntries = this.allAllowedRoleEntriesForSKU,
ConfigurationSession = this.configurationSession,
OrgContainerId = base.OrgContainerId,
OrganizationId = ((null != base.CurrentOrganizationId) ? base.CurrentOrganizationId : base.ExecutingUserOrganizationId),
Organization = this.Organization,
RolesContainerId = this.rolesContainerId,
ServicePlanSettings = base.ServicePlanSettings,
WriteVerbose = new Task.TaskVerboseLoggingDelegate(base.WriteVerbose),
WriteError = new Task.TaskErrorLoggingDelegate(base.WriteError),
WriteWarning = new Task.TaskWarningLoggingDelegate(this.WriteWarning),
LogReadObject = new RoleUpgradeConfigurationSettings.LogReadObjectDelegate(base.LogReadObject),
LogWriteObject = new RoleUpgradeConfigurationSettings.LogWriteObjectDelegate(base.LogWriteObject),
RemoveRoleAndAssignments = new RoleUpgradeConfigurationSettings.RemoveRoleAndAssignmentsDelegate(this.RemoveRoleAndAssignments),
Task = this
};
this.RenameEndUserRolesForUnifiedRAP();
using (List <RoleNameMapping> .Enumerator enumerator = mapping.GetEnumerator())
{
while (enumerator.MoveNext())
{
RoleNameMapping map = enumerator.Current;
if (!map.IsSplitting && !map.IsDeprecatedRole)
{
List <RoleDefinition> list2 = roleDefinitions.ToList <RoleDefinition>().FindAll((RoleDefinition x) => x.RoleName.Equals(map.NewName));
if (list2 != null && list2.Count <RoleDefinition>() > 0)
{
RoleUpgrader roleUpgrader = RoleUpgraderFactory.GetRoleUpgrader(settings, map, list2[0]);
roleUpgrader.UpdateRole(list2[0]);
}
}
}
}
List <RoleDefinition> list3 = new List <RoleDefinition>();
foreach (RoleDefinition roleDefinition in roleDefinitions)
{
if (!list.Contains(roleDefinition))
{
if (!string.IsNullOrEmpty(roleDefinition.ParentRoleName))
{
list3.Add(roleDefinition);
}
else
{
new List <RoleNameMapping>();
List <RoleNameMapping> nonRenamingMappings = mapping.GetNonRenamingMappings(roleDefinition.RoleName);
if (nonRenamingMappings != null)
{
using (List <RoleNameMapping> .Enumerator enumerator2 = nonRenamingMappings.GetEnumerator())
{
while (enumerator2.MoveNext())
{
RoleNameMapping roleNameMapping = enumerator2.Current;
if (roleNameMapping.NewNames == null)
{
throw new InvalidOperationException("Invalid MAP:" + roleNameMapping.OldName);
}
RoleUpgrader roleUpgrader2 = RoleUpgraderFactory.GetRoleUpgrader(settings, roleNameMapping, roleDefinition);
List <RoleDefinition> list4 = new List <RoleDefinition>();
list4 = this.GetRoleDefinitionsByName(roleDefinitions, roleNameMapping.NewNames);
if (roleNameMapping.IsSplitting)
{
list4.Add(roleDefinition);
}
roleUpgrader2.UpdateRoles(list4);
foreach (RoleDefinition item in list4)
{
List <RoleNameMapping> nonRenamingMappings2 = mapping.GetNonRenamingMappings(item.RoleName);
if (nonRenamingMappings2 == null)
{
list.Add(item);
}
else if (nonRenamingMappings2.Count == 1 && nonRenamingMappings2[0].Equals(roleNameMapping))
{
list.Add(item);
}
}
}
goto IL_363;
}
}
RoleUpgrader roleUpgrader3 = RoleUpgraderFactory.GetRoleUpgrader(settings, null, roleDefinition);
roleUpgrader3.UpdateRole(roleDefinition);
}
}
IL_363 :;
}
this.InstallCustomRoles(list3);
TaskLogger.LogExit();
}
internal static void CalculateRoleConfigurationForCurrentSKU(OrganizationIdParameter organization, ServicePlan servicePlanSettings, out RoleDefinition[] roles, out RoleNameMappingCollection nameMapping, out string[] rolesToRemove, out RoleEntry[] allAllowedRoleEntriesForSKU)
{
if (InstallCannedRbacRoles.isFfoEnvironment)
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedEOPRoles_Datacenter.Definition, CannedWebServiceRoles_Datacenter.Definition);
roles = InstallCannedRbacRoles.MergeRoleDefinitions(roles, CannedUCCRoles_Datacenter.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingDatacenterR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesDatacenter;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableEOPRoleEntries_Datacenter.RoleEntries, AvailableWebServiceRoleEntries_Datacenter.RoleEntries, AvailableUCCRoleEntries_Datacenter.RoleEntries);
return;
}
if (organization == null)
{
if (Datacenter.IsMicrosoftHostedOnly(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Datacenter.Definition, CannedWebServiceRoles_Datacenter.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingDatacenterR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesDatacenter;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Datacenter.RoleEntries, AvailableWebServiceRoleEntries_Datacenter.RoleEntries, null);
return;
}
if (Datacenter.IsPartnerHostedOnly(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Hosting.Definition, CannedWebServiceRoles_Hosting.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingHostingR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesHosting;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Hosting.RoleEntries, AvailableWebServiceRoleEntries_Hosting.RoleEntries, null);
return;
}
if (Datacenter.IsDatacenterDedicated(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Dedicated.Definition, CannedWebServiceRoles_Dedicated.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingEnterpriseR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesEnterprise;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Dedicated.RoleEntries, AvailableWebServiceRoleEntries_Dedicated.RoleEntries, null);
return;
}
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Enterprise.Definition, CannedWebServiceRoles_Enterprise.Definition);
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingEnterpriseR4;
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesEnterprise;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Enterprise.RoleEntries, AvailableWebServiceRoleEntries_Enterprise.RoleEntries, null);
return;
}
else
{
if (Datacenter.IsPartnerHostedOnly(false))
{
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_HostedTenant.Definition, CannedWebServiceRoles_HostedTenant.Definition);
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesHostedTenant;
if (servicePlanSettings != null)
{
List <string> enabledRoleGroupRoleAssignmentFeatures = servicePlanSettings.Organization.GetEnabledRoleGroupRoleAssignmentFeatures();
RoleGroupRoleMapping[] definition = HostedTenant_RoleGroupDefinition.Definition;
List <string> a;
roles = InstallCannedRbacRoles.FilterOrgRolesByRoleGroupFilters(roles, enabledRoleGroupRoleAssignmentFeatures, definition, out a);
rolesToRemove = InstallCannedRbacRoles.AppendIListToarray <string>(rolesToRemove, a);
}
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingHostedTenantR4;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_HostedTenant.RoleEntries, AvailableWebServiceRoleEntries_HostedTenant.RoleEntries, null);
return;
}
roles = InstallCannedRbacRoles.MergeRoleDefinitions(CannedRoles_Tenant.Definition, CannedWebServiceRoles_Tenant.Definition);
rolesToRemove = InstallCannedRbacObjectsTaskBase.ObsoleteRoleNamesTenant;
if (servicePlanSettings != null)
{
List <string> enabledRoleGroupRoleAssignmentFeatures2 = servicePlanSettings.Organization.GetEnabledRoleGroupRoleAssignmentFeatures();
RoleGroupRoleMapping[] definition2 = Tenant_RoleGroupDefinition.Definition;
List <string> a2;
roles = InstallCannedRbacRoles.FilterOrgRolesByRoleGroupFilters(roles, enabledRoleGroupRoleAssignmentFeatures2, definition2, out a2);
rolesToRemove = InstallCannedRbacRoles.AppendIListToarray <string>(rolesToRemove, a2);
}
nameMapping = InstallCannedRbacObjectsTaskBase.RoleNameMappingTenantR4;
allAllowedRoleEntriesForSKU = InstallCannedRbacRoles.MergeRoleEntries(AvailableRoleEntries_Tenant.RoleEntries, AvailableWebServiceRoleEntries_Tenant.RoleEntries, null);
return;
}
}
public void AddToServicePlans(ServicePlan servicePlan)
{
base.AddObject("ServicePlans", servicePlan);
}
