private static bool MatchPredicate(PackageModel packageModel, BinaryPredicate predicate)
{
var expr1 = predicate.Operand1 as Expression;
switch (predicate.Operator)
{
case Operator.OR:
return Match(packageModel, predicate.Operand1) || Match(packageModel, predicate.Operand2);
case Operator.AND:
return Match(packageModel, predicate.Operand1) && Match(packageModel, predicate.Operand2);
case Operator.EQUAL:
case Operator.NOTEQUAL:
case Operator.GREATERTHAN:
case Operator.LESSTHAN:
case Operator.GREATERTHANOREQUAL:
case Operator.LESSTHANOREQUAL:
if (expr1 != null)
{
switch (expr1.Value)
{
case "version": return MatchVersion(packageModel, predicate);
case "arch": return MatchArchitecture(packageModel, predicate);
}
}
break;
}
return true;
}
private static bool MatchExpression(PackageModel packageModel, Expression expression)
{
switch (expression.Value)
{
case "installed": return packageModel.Package.IsInstalled;
case "locked": return packageModel.IsLocked;
case "newest": return !packageModel.Package.NewerPackages.Any();
}
return packageModel.Name.Contains(expression.Value) || packageModel.Flavor.Contains(expression.Value);
}
public TranslationMemoriesPenaltiesViewModel(PackageModel packageModel)
{
_packageModel = packageModel;
if (!(_packageModel is null) && packageModel.TMPenalties == null)
{
{
_packageModel.TMPenalties = new Dictionary <string, int>();
}
}
_translationMemoriesPenaltiesModelList = new ObservableCollection <TranslationMemoriesPenaltiesModel>();
LoadTranslationMemories();
}
public virtual void AppendMissing(PackageModel source)
{
AppendDifference(source, false);
if (generateSource)
{
string p = BuildPath(Path.Combine(this.folderForSource, source.Owner), "PackageBodies", source.Name);
WriteFile(p, CreateOrReplace + source.CodeBody.GetSource());
p = BuildPath(Path.Combine(this.folderForSource, source.Owner), "Packages", source.Name);
WriteFile(p, CreateOrReplace + source.Code.GetSource());
}
}
public IActionResult Setpackage(PackageModel package)
{
MSParameters par = new MSParameters("ref", package.Pck_ref);
Parameter.Add(par);
par = new MSParameters("detailSend", package.Pck_detailSend);
Parameter.Add(par);
par = new MSParameters("progress", package.Pck_progress);
Parameter.Add(par);
par = new MSParameters("IdCustomer", package.Pck_IdCustomer);
Parameter.Add(par);
par = new MSParameters("NameCustomer", package.Pck_NameCustomer);
Parameter.Add(par);
par = new MSParameters("LastNameCustomer", package.Pck_LastNameCustomer);
Parameter.Add(par);
par = new MSParameters("AgeCustomer", package.Pck_AgeCustomer);
Parameter.Add(par);
par = new MSParameters("PhoneCustomer", package.Pck_PhoneCustomer[0] + ";" + package.Pck_PhoneCustomer[1] + ";" + package.Pck_PhoneCustomer[2]);
Parameter.Add(par);
par = new MSParameters("AddressCustomer", package.Pck_AddressCustomer);
Parameter.Add(par);
par = new MSParameters("EmailCustomer", package.Pck_EmailCustomer);
Parameter.Add(par);
par = new MSParameters("NameLastnamebeneficiary", package.Pck_NameLastnamebeneficiary);
Parameter.Add(par);
par = new MSParameters("Phonebeneficiary", package.Pck_Phonebeneficiary[0] + ";" + package.Pck_Phonebeneficiary[1] + ";" + package.Pck_Phonebeneficiary[2]);
Parameter.Add(par);
par = new MSParameters("Addressbeneficiary", package.Pck_Addressbeneficiary);
Parameter.Add(par);
par = new MSParameters("NameCollector", package.Pck_NameCollector);
Parameter.Add(par);
par = new MSParameters("IdCollector", package.Pck_IdCollector);
Parameter.Add(par);
par = new MSParameters("PriceByKg", package.Pck_PriceByKg);
Parameter.Add(par);
par = new MSParameters("KgInSuitCase", package.Pck_KgInSuitCase);
Parameter.Add(par);
par = new MSParameters("Coin", package.Pck_Coin);
Parameter.Add(par);
par = new MSParameters("TypeChange", package.Pck_TypeChange);
Parameter.Add(par);
par = new MSParameters("TotalPrice", package.Pck_TotalPrice);
Parameter.Add(par);
par = new MSParameters("Date", package.Pck_Date);
Parameter.Add(par);
par = new MSParameters("detailArticles", package.Pck_detailArticles);
Parameter.Add(par);
return(new JsonResult(MSutil.ExecuteStopProcedureToJson("Setpackage", Parameter)));
}
public (MessageModel, IProject) CreateProject(PackageModel package)
{
var target = _fileService.GetStudioTargetLanguages(package.LanguagePairs);
var projectInfo = new ProjectInfo
{
Name = package.Name,
LocalProjectFolder = package.Location,
SourceLanguage = new Language(package.LanguagePairs[0].SourceLanguage),
TargetLanguages = target,
DueDate = package.DueDate,
ProjectOrigin = "Star Transit project",
IconPath = _iconPath
};
var newProject = CreateNewProject(projectInfo, new ProjectTemplateReference(package.ProjectTemplate.Uri));
if (package.Customer != null)
{
((FileBasedProject)newProject).SetCustomer(package.Customer);
}
//Add StarTransit package source files. The same on all language pairs
newProject.AddFiles(package.LanguagePairs[0].SourceFile.ToArray());
//set the file role(user to display project details in Studio view)
var sourceFilesIds = newProject.GetSourceLanguageFiles().GetIds();
newProject.SetFileRole(sourceFilesIds, FileRole.Translatable);
_tmConfig = newProject.GetTranslationProviderConfiguration();
_messageModel = SetLanguagePairInformation(newProject, package);
if (_messageModel?.Message is null)
{
if (Directory.Exists(newProject?.GetProjectInfo()?.LocalProjectFolder))
{
CreateMetadataFolder(package.Location, package.PathToPrjFile);
_projectsController?.RefreshProjects();
}
if (_messageModel != null)
{
_messageModel.IsProjectCreated = true;
_messageModel.Message = "Project was successfully created!";
_messageModel.Title = "Informative message";
}
}
return(_messageModel, newProject);
}
//套餐日期 一開始先全抓
public static List <PkgDateforEcModel> getProdPkgDate(PackageModel pkg, string lang, string currency, Dictionary <string, string> uikey, out string allCanUseDate)
{
List <PkgDateforEcModel> pkgDateList = new List <PkgDateforEcModel>();
string allCanUseDateTemp = "";
//要判斷是否是0000
PkgSaleDateModel sale_dates = pkg.sale_dates;
foreach (SaleDt s in sale_dates.saleDt)
{
string pkgOid = s.pkg_no.ToString();
DateTime day = DateTimeTool.yyyyMMdd2DateTime(s.sale_day);
//string day = s.sale_day.ToString();
//先建立ProductPkgDateModel ,有新的就加
string[] pkgid = pkgOid.Split(",");
foreach (string id in pkgid)
{
var result = pkgDateList.Where(x => x.pkgOid.ToString() == id);
if (result.Count() > 0)
{
foreach (PkgDateforEcModel pd in result)
{
pd.day = pd.day + day.ToString("yyyy-MM-dd") + ",";
}
}
else
{
PkgDateforEcModel pd = new PkgDateforEcModel();
pd.pkgOid = id;
pd.day = day.ToString("yyyy-MM-dd") + ",";
pkgDateList.Add(pd);
}
}
allCanUseDateTemp = allCanUseDateTemp + day.ToString("yyyy-MM-dd") + ",";
}
//去最後逗號
foreach (PkgDateforEcModel pkgDate in pkgDateList)
{
if (pkgDate.day.Length != 0)
{
pkgDate.day = pkgDate.day.Substring(0, pkgDate.day.Length - 1);
}
}
allCanUseDate = allCanUseDateTemp.Length > 0 ? allCanUseDateTemp.Substring(0, allCanUseDateTemp.Length - 1) : allCanUseDateTemp;
return(pkgDateList);
}
private MessageModel SetLanguagePairInformation(
IProject newProject,
PackageModel package)
{
if (package?.LanguagePairs != null)
{
foreach (var pair in package.LanguagePairs)
{
if (!pair.TargetFile.Any() || pair.TargetFile.Count == 0)
{
_messageModel.IsProjectCreated = false;
_messageModel.Message =
"Project was not created correctly because no target files were found in the package!";
_messageModel.Title = "Informative message";
return(_messageModel);
}
if (pair.CreateNewTm)
{
//TODO:Investigate and refactor
foreach (var starTmMetadata in pair.StarTranslationMemoryMetadatas)
{
AddTmPenalties(package, starTmMetadata);
AddMtMemories(package, starTmMetadata);
}
//TODO: Investigate if we really need this later we'll join the mt and tms becasue
// Remove found items from pair.StarTranslationMemoryMetadatas (the remained ones are those which does not have penalties set on them)
foreach (var item in _penaltiesTmsList)
{
pair.StarTranslationMemoryMetadatas.Remove(item);
}
// Remove Machine Translation memories from pair.StarTranslationMemoryMetadatas, if the user requests them, they will be imported separately, but never in the main TM
pair.StarTranslationMemoryMetadatas.RemoveAll(item =>
Path.GetFileName(item?.TargetFile ?? "").Contains("_AEXTR_MT_"));
}
_targetProjectFiles?.Clear();
// Import language pair TM if any
ImportLanguagePairTm(pair, newProject, package);
_targetProjectFiles?.AddRange(newProject.AddFiles(pair.TargetFile.ToArray()));
_messageModel = UpdateProjectSettings(newProject);
}
_projectsController?.RefreshProjects();
}
return(_messageModel);
}
public RecipeDrugModel(RecipeDrug entity)
{
ID = entity.ID;
PackageID = entity.PackageID;
Package = new PackageModel(entity.Package);
UserID = entity.ClientID;
User = new UserModel(entity.Client);
MadeByID = entity.MadeByID;
MadeBy = entity.MadeBy == null ? null : new EmployeeModel(entity.MadeBy);
EvaluatedDate = entity.EvaluatedDate;
CreatedDate = entity.CreatedDate;
Status = (OrderStatusEnum)entity.StatusID;
Ingridients = entity.Ingridients.Select(x => new IngridientModel(x)).ToList() ?? new List <IngridientModel>(5);
}
public void AddPackage(PackageModel packageModel)
{
var package = new PackageInfo
{
Name = packageModel.Name,
Version = packageModel.Version,
Path = packageModel.Path
};
lock (_lock)
{
_packages.Add(package);
}
}
public PackageModel GetDetail(int packageId)
{
var result = (from a in _entAT.Air_Packages
where a.IsPublish == true
select new { a }
).Where(x => x.a.PackageId == packageId).FirstOrDefault();
PackageModel model = new PackageModel();
if (result != null)
{
model = new PackageModel
{
PackageId = result.a.PackageId,
CountryId = result.a.CountryId,
CityId = result.a.CityId,
Name = result.a.Name,
PackageCode = result.a.PackageCode,
URL = result.a.URL,
StartingPrice = Convert.ToDecimal(result.a.StartingPrice),
Description = result.a.Description,
Overview = result.a.Overview,
Itineary = result.a.Itineary,
Destination = result.a.Destination,
TermAndConditions = result.a.TermAndConditions,
InclusiveAndExclusive = result.a.InclusiveAndExclusive,
Rate = result.a.Rate,
ImageFolderName = result.a.ImageFolderName,
EffectiveFrom = result.a.EffectiveFrom,
ExpireOn = result.a.ExpireOn,
B2CMarkup = result.a.B2CMarkup,
CreatedBy = result.a.CreatedBy,
CreatedDate = result.a.CreatedDate,
UpdatedBy = result.a.UpdatedBy,
UpdatedDate = result.a.UpdatedDate,
IsPublish = result.a.IsPublish,
};
}
var resultImageList = (from b in _entAT.Air_PackagesImage
where b.PackageId == result.a.PackageId
select new { ImageName = b.ImageName, IsDefault = b.IsDefault });
model.ImageNameList = resultImageList.Select(x => x.ImageName).ToList();
model.DefaultImageName = resultImageList.OrderByDescending(x => x.IsDefault).Select(x => x.ImageName).FirstOrDefault();
model.StartingPrice = Convert.ToDecimal(result.a.StartingPrice) + (result.a.B2BMarkUp != null ? Convert.ToDecimal(result.a.B2BMarkUp) : 0);
return(model);
}
public bool UpdatePackage(string trackingNumber, PackageModel package)
{
var existing = _localPackages.SingleOrDefault(p => p.TrackingNumber == trackingNumber);
if (existing == null)
{
return(false);
}
_localPackages.Remove(existing);
_localPackages.Add(package);
return(true);
}
/// <summary>
/// </summary>
/// <param name="reader"> </param>
/// <param name="version"> </param>
/// <returns> When the reader parses the embedded package model we sync that back to the exposed model right away. </returns>
protected override bool TryParseElement(XmlReader reader, string version)
{
try {
var extension = Model.XmlSerializer.Deserialize(reader) as PackageModel;
if (extension != null)
{
Model = extension;
SyncToModel();
}
return(Model != null);
} catch {
}
return(false);
}
public StarTransitMainWindow(PackageModel package)
{
EnsureApplicationResources();
InitializeComponent();
_packageDetails = new PackageDetails(package);
var packageModel = PackageDetailsViewModel.GetPackageModel();
_translationMemories = new TranslationMemories();
_finish = new Finish(packageModel);
DataContext = new StarTransitMainWindowViewModel(_packageDetails, _translationMemories, _finish);
// DataContext = new StarTransitMainWindowViewModel(packageModel);
}
/// <summary>
/// Return view to update a package
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult UpdatePackage(int id)
{
PackageModel model = new PackageModel();
try //try and get a package
{
var package = (ServiceRequestPackageDto)_portfolioService.GetServiceRequestPackage(UserId, id);
model.Name = package.Name;
model.Action = package.Action;
if (package.ServiceOptionCategoryTags != null)
{
model.SelectedCategories = from a in package.ServiceOptionCategoryTags select a.ServiceOptionCategoryId; //fill selections
if (package.ServiceOptionCategoryTags.FirstOrDefault(x => x.Order == 1) != null) //figure out primary
{
model.PrimaryIsService = false;
model.PrimaryId = (from c in package.ServiceOptionCategoryTags where c.Order == 1 select c.ServiceOptionCategoryId).First();
}
}
if (package.ServiceTags != null)
{
model.SelectedServices = from a in package.ServiceTags select a.ServiceId; //fill sections
if (package.ServiceTags.FirstOrDefault(x => x.Order == 1) != null) //figure out primary if it is in here
{
model.PrimaryIsService = true;
model.PrimaryId = (from c in package.ServiceTags where c.Order == 1 select c.ServiceId).First();
}
}
}
catch (Exception exception)
{
TempData["MessageType"] = WebMessageType.Failure;
TempData["Message"] = $"Failed to retrieve service package, error: {exception.Message}";
}
try //build services list to select from
{
var services = _catalogController.RequestBusinessCatalog(UserId).ToList(); //build list
services.AddRange(_catalogController.RequestSupportCatalog(UserId));
model.Services = services;
}
catch (Exception exception)
{
TempData["MessageType"] = WebMessageType.Failure;
TempData["Message"] = $"failed to obtain services, error: {exception.Message}";
}
return(View(model));
}
[HttpPost]//[AcceptVerbs("Post")]
public IActionResult reflashPkg([FromBody] prodQury prodQury)
{
try
{
//B2d分銷商資料
var aesUserData = User.Identities.SelectMany(i => i.Claims.Where(c => c.Type == ClaimTypes.UserData).Select(c => c.Value)).FirstOrDefault();
var UserData = JsonConvert.DeserializeObject <B2dAccount>(AesCryptHelper.aesDecryptBase64(aesUserData, Website.Instance.AesCryptKey));
//先確認是否有selDate ,如果沒有表示是第一次
//如果有 selDate要依selDate決定可用的套餐
string allCanUseDate = "";
//取挖字
Dictionary <string, string> uikey = CommonRepostory.getuiKey(RedisHelper, UserData.LOCALE);;// Redishelper.getuiKey(fakeContact.lang);
ProdTitleModel title = ProductRepostory.getProdTitle(uikey);
ViewData["prodTitle"] = title;
ViewData["currency"] = UserData.CURRENCY;//先從這裡取得幣別就不用再抓prod
//ProductforEcModel prod = ApiHelper.getProdDtl(fakeContact.companyXid, fakeContact.state, fakeContact.lang, fakeContact.currency, prodQury.prodOid);
//prod = prodRep.getProdInfo(prod, prodQury.prodOid, fakeContact.lang, fakeContact.currency, uikey); //prod.guidNo = guid;
//ViewData["prodInfo"] = prod;
PackageModel pkgs = ProductRepostory.getProdPkg(UserData.COMPANY_XID, UserData.COUNRTY_CODE, UserData.LOCALE, UserData.CURRENCY, prodQury.prodOid, title);
Int64 nowDatetime = Convert.ToInt64(DateTime.Now.ToString("yyyyMMddHHmmss"));
pkgs.pkgs = pkgs.pkgs.Where(x => nowDatetime >= Convert.ToInt64(x.online_s_date) && Convert.ToInt64(x.online_e_date) > nowDatetime).ToList();
Website.Instance.logger.Debug($"product_reflashPkg_err:{JsonConvert.SerializeObject(pkgs)}");
List <PkgDateforEcModel> prodPkgDateList = ProductRepostory.getProdPkgDate(pkgs, UserData.LOCALE, UserData.CURRENCY, uikey, out allCanUseDate);
//設定每個pkg裡面可以使用的日期有那些
pkgs = ProductRepostory.InitPkg(prodQury, title, pkgs, prodPkgDateList);
return(Content(this.RenderPartialViewToString(ViewEngine, "_prodPkg", pkgs)));
}
catch (Exception ex)
{
//error
Website.Instance.logger.Debug($"product_reflashPkg_err:{ex.ToString()}");
returnStatus status = new returnStatus();
status.status = "Error";
status.msgErr = "資料錯誤，請重新讀取頁";//要改
return(Json(status));
}
}
/// <summary>
/// Reads the metadata from .PRJ file
/// </summary>
/// <param name="pathToTempFolder"></param>
/// <param name="fileName"></param>
/// <returns></returns>
private async Task <PackageModel> ReadProjectMetadata(string pathToTempFolder, string fileName)
{
var filePath = Path.Combine(pathToTempFolder, fileName);
var keyProperty = string.Empty;
using (var reader = new StreamReader(filePath))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith("[") && line.EndsWith("]"))
{
var valuesDictionaries = new List <KeyValuePair <string, string> >();
if (keyProperty != string.Empty && _dictionaryPropetries.Count != 0)
{
valuesDictionaries.AddRange(
_dictionaryPropetries.Select(
property => new KeyValuePair <string, string>(property.Key, property.Value)));
if (_pluginDictionary.ContainsKey(keyProperty))
{
_pluginDictionary[keyProperty].AddRange(valuesDictionaries);
}
else
{
_pluginDictionary.Add(keyProperty, valuesDictionaries);
}
_dictionaryPropetries.Clear();
}
var firstPosition = line.IndexOf("[", StringComparison.Ordinal) + 1;
var lastPosition = line.IndexOf("]", StringComparison.Ordinal) - 1;
keyProperty = line.Substring(firstPosition, lastPosition);
}
else
{
var properties = line.Split('=');
_dictionaryPropetries.Add(new KeyValuePair <string, string>(properties[0], properties[1]));
}
}
}
var packageModel = await CreateModel(pathToTempFolder);
packageModel.PathToPrjFile = filePath;
_package = packageModel;
return(packageModel);
}
//Separate all items from package.MachineTransMem (files that contain Machine Translation)
private void AddMtMemories(PackageModel package, StarTranslationMemoryMetadata starTmMetadata)
{
if (package?.MTMemories == null)
{
return;
}
var hasMtMemories = package.MTMemories.Any(t => t.Equals(starTmMetadata.TargetFile));
if (!hasMtMemories)
{
return;
}
starTmMetadata.TMPenalty = 1;
_machineTransList.Add(starTmMetadata);
}
// Create separate TM for each TM file on which user set penalty. The penalty is applied on top of any penalty that might be applied by the translation provider itself.
// The name of the new TM will be the same with the one from StarTransit package
// We'll create a single project which will contain all the tms and mt.
private void CreateSeparateTms(LanguagePair pair, IProject project, PackageModel package)
{
var allTransitTms = _penaltiesTmsList?.Concat(_machineTransList).ToList();
if (allTransitTms != null && !allTransitTms.Any())
{
return;
}
var tpReference = CreateTpReference(allTransitTms, pair, project, package);
foreach (var tpRef in tpReference)
{
_tmConfig.Entries.Add(new TranslationProviderCascadeEntry(tpRef.Key, true, true, true, tpRef.Value));
}
}
private static bool MatchArchitecture(PackageModel packageModel, BinaryPredicate predicate)
{
var expr2 = predicate.Operand2 as Expression;
if (expr2 != null)
{
switch (predicate.Operator)
{
case Operator.EQUAL: return packageModel.Architecture == expr2.Value;
case Operator.NOTEQUAL: return packageModel.Architecture != expr2.Value;
}
}
return true;
}
/// <summary>
/// Loads all outdated choco packages
/// </summary>
private void LoadOutdatedChocoPackages()
{
var pcks = Choco.OutdatedPackages(false);
Dispatcher.BeginInvoke(new Action(() =>
{
IsLoading = false;
foreach (var pck in pcks)
{
var model = new PackageModel(pck.Name, pck.OldVersion, pck.NewVersion, pck.IsPinned);
model.IsSelectedChanged += IsSelectedChanged;
Packages.Add(model);
}
}));
}
/// <summary>
/// Determines whether the specified package is valid or not.
/// </summary>
/// <param name="package">The package.</param>
/// <returns>
/// <c>true</c> if the specified package is valid; otherwise, <c>false</c>.
/// </returns>
private bool IsPackageValid(PackageModel package)
{
string packageConfigurationFileFullName =
Path.Combine(_packageTestPath, $"{package.Name}.json");
string packageFileFullName =
Path.Combine(_packageTestPath, $"{package.Name}.zip");
if (!File.Exists(packageConfigurationFileFullName) || !File.Exists(packageFileFullName))
{
return(false);
}
return(CryptographyHelper.GetMd5HashFromFile(packageFileFullName).Equals(package.Hash));
}
public ActionResult Edit(Int64 id)
{
var package_srv = CompositionRoot.Resolve <IPackageService>();
var package = package_srv.GetPackageById(id);
if (package == null)
{
throw new Exception(string.Format("Не найден пакет с идентификатором {0}", id));
}
PackageModel model = PackageHelper.CreateModel(package);
return(View(model));
}
public static Package CreatePackage(PackageModel model)
{
var org_srv = CompositionRoot.Resolve <IOrganizationService>();
var user_srv = CompositionRoot.Resolve <IUserService>();
Package package = new Package {
Id = model.Id,
Date = model.Date,
Organization = org_srv.GetOrganizationById(model.OrganizationId),
Controller = user_srv.GetUserById(model.ControllerId),
Comment = model.Comment
};
return(package);
}
public ActionResult AddPackage(PackageModel newPackage)
{
if (ModelState.IsValid)
{
bool CanAddPackage = packageDetails.VerifyPackage(newPackage.PackageName);
if (CanAddPackage)
{
var package = AutoMapper.Mapper.Map <PackageModel, Package>(newPackage); //Automapping package details from model to entity
packageDetails.AddPackage(package); //Adding the package to the database
return(RedirectToAction("DisplayPackages")); //Redirecting after adding the package
}
TempData["Message"] = "Package already exists!!";
}
return(View());
}
public ActionResult Create(PackageModel model)
{
if (model.PackageDetailList == null)
{
TempData["message"] = "Add items to package !!";
return(View());
}
if (ent.PackageMasters.Any(x => x.PackageName == model.PackageName))
{
TempData["message"] = "Package with this name already exits !!";
return(View(model));
}
try
{
var obj = AutoMapper.Mapper.Map <PackageModel, PackageMaster>(model);
obj.Status = true;
obj.Vat = Convert.ToDecimal(0);
obj.VatAmount = Convert.ToDecimal(0);
obj.CreatedBy = Utility.GetCurrentLoginUserId();
obj.CreatedDate = DateTime.Now;
ent.PackageMasters.Add(obj);
ent.SaveChanges();
foreach (var item in model.PackageDetailList)
{
var detail = new PackageDetail();
detail.PackageId = obj.PackageId;
detail.DeptId = item.DeptId;
detail.TestId = item.TestId;
if (item.DeptId == 1006)
{
detail.SectionId = (int)ent.SetupPathoTests.Where(x => x.TestId == item.TestId).SingleOrDefault().SectionId;
}
else
{
detail.SectionId = 0;
}
detail.Status = true;
ent.PackageDetails.Add(detail);
}
ent.SaveChanges();
TempData["message"] = "Package created successfully !!";
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public void InvalidInputs()
{
//Arrange
string weight = "a";
string height = "b";
string width = "c";
string length = "d";
//Act
Package package = new Package(weight, height, width, length);
PackageModel packageModel = package.InitPackage();
//Assert
Assert.AreEqual(packageModel, null);
Assert.IsTrue(Log._logs.Count > 0);
}
public ActionResult NewPackage(string param = "")
{
PackageModel packagemodel = JsonConvert.DeserializeObject <PackageModel>(param);
long result = 0;
if (packagemodel.Packageid != null)
{
result = _service.PackageRepository.UpdatePackagesDetails(packagemodel);
}
else
{
result = _service.PackageRepository.InsertPackagesDetails(packagemodel);
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void ShouldListPackages()
{
var files = PackageModel.FindFiles(root);
AreEqual(3, files.Length);
var file1 = files.First();
var model1 = PackageModel.LoadFile(file1);
AreEqual("{'Id':'CommandLineParser','Version':'2.1.1-beta','TargetFramework':'net451'}",
model1.Entries.First().ToJson());
var file2 = files.Last();
var model2 = PackageModel.LoadFile(file2);
AreEqual("{'Id':'Newtonsoft.Json','Version':'10.0.2','TargetFramework':'net451'}",
model2.Entries.First().ToJson());
}
public ActionResult Index(PackageModel model)
{
using (Models.CustomersEntities entities = new Models.CustomersEntities())
{
Customer customer = entities.Customers.FirstOrDefault(x => x.EmailAddress == User.Identity.Name);
customer.CustomerPackages.Remove(customer.CustomerPackages.First());
customer.CustomerPackages.Add(new CustomerPackage {
PackageID = model.id
});
entities.SaveChanges();
return(RedirectToAction("Index", "checkout"));
}
}
public ActionResult Create(PackageModel package)
{
try
{
string item = Request.Form.GetValues("Items") != null?Request.Form.GetValues("Items")[0] : "";
package.Item = ItemManager.GetItemByID(int.Parse(item.ToString()), "nirshan");
PackageManager.AddPackage(Utility.convertSrcToTarget <PackageModel, Package>(package), "nirshan");
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public PackageModelFacts()
{
_content = new Mock <IPackageContentService>();
_packages = new Mock <IPackageService>();
_search = new Mock <ISearchService>();
_url = new Mock <IUrlGenerator>();
_target = new PackageModel(
_packages.Object,
_content.Object,
_search.Object,
_url.Object);
_search
.Setup(s => s.FindDependentsAsync("testpackage", _cancellation))
.ReturnsAsync(new DependentsResponse());
}
public static IEnumerable <ResultFile> Generate(string discoveryJson, Features features, PackageEnumStorage enumStorage)
{
discoveryJson = NormalizeDescriptions(discoveryJson);
var discoveryDescription = NewtonsoftJsonSerializer.Instance.Deserialize <RestDescription>(discoveryJson);
var package = new PackageModel(discoveryDescription, features, enumStorage);
yield return(GenerateCSharpCode(package));
yield return(GenerateProjectFile(package));
yield return(GenerateNet40Config(package));
yield return(GenerateNetStandard10Config(package));
}
private static bool MatchVersion(PackageModel packageModel, BinaryPredicate predicate)
{
var expr2 = predicate.Operand2 as Expression;
if (expr2 != null)
{
switch (predicate.Operator)
{
case Operator.EQUAL: return packageModel.Package.Version == expr2.Value;
case Operator.NOTEQUAL: return packageModel.Package.Version != expr2.Value;
case Operator.GREATERTHAN: return packageModel.Package.Version > expr2.Value;
case Operator.LESSTHAN: return packageModel.Package.Version < expr2.Value;
case Operator.GREATERTHANOREQUAL: return packageModel.Package.Version >= expr2.Value;
case Operator.LESSTHANOREQUAL: return packageModel.Package.Version <= expr2.Value;
}
}
return true;
}
public AtomItem(PackageModel model)
{
Model = model;
}
public AtomItem()
{
Model = new PackageModel();
}
public AtomItem(Package package)
{
Model = new PackageModel {
CanonicalName = package.CanonicalName,
DisplayName = package.DisplayName,
Vendor = package.Vendor,
BindingPolicy = package.BindingPolicy,
Roles = package.PackageRoles,
Dependencies = package.PackageDependencies.ToXDictionary(each => each.CanonicalName, each => each.FeedLocations),
Features = package.Features,
RequiredFeatures = package.RequiredFeatures,
Feeds = package.FeedLocations,
Locations = package.RemotePackageLocations,
PackageDetails = package.PackageDetails
};
// when complete,
SyncFromModel();
}
/// <summary>
/// </summary>
/// <param name="reader"> </param>
/// <param name="version"> </param>
/// <returns> When the reader parses the embedded package model we sync that back to the exposed model right away. </returns>
protected override bool TryParseElement(XmlReader reader, string version)
{
try {
var extension = Model.XmlSerializer.Deserialize(reader) as PackageModel;
if (extension != null) {
Model = extension;
SyncToModel();
}
return Model != null;
} catch {
}
return false;
}
internal static bool Match(PackageModel packageModel, IOperand operand)
{
var expression = operand as Expression;
if (expression != null)
return MatchExpression(packageModel, expression);
else
return MatchPredicate(packageModel, operand);
}
private static bool MatchPredicate(PackageModel packageModel, UnaryPredicate predicate)
{
var expr1 = predicate.Operand as Expression;
switch (predicate.Operator)
{
case Operator.NOT:
return !Match(packageModel, predicate.Operand);
}
return true;
}
private static bool MatchPredicate(PackageModel packageModel, IOperand predicate)
{
if (predicate is UnaryPredicate)
return MatchPredicate(packageModel, (UnaryPredicate)predicate);
else if (predicate is BinaryPredicate)
return MatchPredicate(packageModel, (BinaryPredicate)predicate);
return true;
}
public AtomItem(Package package)
{
Model = new PackageModel();
Model.Name = package.Name;
// var arch = Architecture.Unknown;
// Enum.TryParse(package.Architecture, true, out arch);
Model.Architecture = package.Architecture;
Model.DisplayName = package.DisplayName;
Model.Vendor = package.Vendor;
Model.Version = package.Version;
Model.PublicKeyToken = package.PublicKeyToken;
Model.BindingPolicyMinVersion = package.InternalPackageData.PolicyMinimumVersion;
Model.BindingPolicyMaxVersion = package.InternalPackageData.PolicyMaximumVersion;
Model.Roles = new List<Role>(package.InternalPackageData.Roles);
Model.Dependencies = package.InternalPackageData.Dependencies.Where(each => each.ProductCode.HasValue).Select(each => each.ProductCode.Value).ToList();
if (!package.InternalPackageData.Features.IsNullOrEmpty()) {
Model.Features = new List<Feature>(package.InternalPackageData.Features);
}
if (!package.InternalPackageData.RequiredFeatures.IsNullOrEmpty()) {
Model.RequiredFeatures = new List<Feature>(package.InternalPackageData.RequiredFeatures);
}
Model.Feeds = package.InternalPackageData.FeedLocations.Select(each => each.ToUri()).ToList();
Model.Locations = package.InternalPackageData.RemoteLocations.Select(each => each.ToUri()).ToList();
// heh-heh, this makes life ... EASY!
// Note: Should this be a clone?
Model.PackageDetails = package.PackageDetails;
// when complete,
SyncFromModel();
}
internal static PackageDetails GetPackageDetails(Package pkg, PackageModel model)
{
return model.PackageDetails;
}
/// <summary>
/// This adds a new package model to the feed. The package model doesn't have to be completed when added,
/// but the caller must fill in the values before the feed is generated, or it's kinda pointless. :)
///
/// Use this when trying to create feeds.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public AtomItem Add(PackageModel model)
{
lock (this) {
var item = new AtomItem(model);
Items = Items.Where(each => each.Id != item.Id).Union(item.SingleItemAsEnumerable()).ToArray();
return item;
}
}
