public XDocument Serialize()
 {
     return(new XDocument(new XElement(EspdNames.Qarq + nameof(QualificationApplicationRequest),
                                       new XAttribute(XNamespace.Xmlns + "cbc", UblNames.Cbc),
                                       new XAttribute(XNamespace.Xmlns + "cac", UblNames.Cac),
                                       UBLVersionID.Serialize(nameof(UBLVersionID)),
                                       CustomizationID.Serialize(nameof(CustomizationID)),
                                       ProfileID.Serialize(nameof(ProfileID)),
                                       ProfileExecutionID.Serialize(nameof(ProfileExecutionID)),
                                       ID?.Serialize(nameof(ID)),
                                       CopyIndicator.Serialize(nameof(CopyIndicator)),
                                       UUID.Serialize(nameof(UUID)),
                                       ContractFolderID.Serialize(nameof(ContractFolderID)),
                                       IssueDate.Serialize(nameof(IssueDate)),
                                       IssueTime.Serialize(nameof(IssueTime)),
                                       VersionID.Serialize(nameof(VersionID)),
                                       PreviousVersionID.Serialize(nameof(PreviousVersionID)),
                                       ProcedureCode.Serialize(nameof(ProcedureCode)),
                                       QualificationApplicationTypeCode.Serialize(nameof(QualificationApplicationTypeCode)),
                                       WeightScoringMethodologyNote.Serialize(nameof(WeightScoringMethodologyNote)),
                                       WeightingTypeCode.Serialize(nameof(WeightingTypeCode)),
                                       ContractingParty?.Serialize(),
                                       ProcurementProject?.Serialize(),
                                       ProcurementProjectLots?.Select(lot => lot.Serialize()),
                                       TenderingCriteria?.Select(c => c.Serialize()),
                                       AdditionalDocumentReferences?.Select(d => d.Serialize())
                                       )));
 }
Example #2
0
        }         // constructor

        private void Init()
        {
            Packed = string.Format(
                "{1}{0}{2}{0}{3}{0}{4}", Separator,
                Random.ToString("N"), UserName, RemoteAddress, IssueTime.ToString(TimeFormat, Culture)
                );

            Encoded = Convert.ToBase64String(new Encrypted(Packed));
        }         // Init
Example #3
0
        public static void TryDelete(Account requester, DataContext context, int id)
        {
            if (!requester.IsAtLeastManagement())
            {
                throw new ServerAuthorizeException("Du har inte behörighet att radera konto");
            }
            // Issues -- delete NOT OK
            Issue issue = context.Issues.FirstOrDefault(i => id == i.residentid);

            if (issue != null)
            {
                throw new ServerConflictException("Konto används som boende i ärende " + issue.id);
            }

            issue = context.Issues.FirstOrDefault(i => id == i.assignedid);
            if (issue != null)
            {
                throw new ServerConflictException("Konto används som tilldelad i ärende " + issue.id);
            }

            IssueMaterial issuematerial = context.IssueMaterials.FirstOrDefault(i => id == i.createdby);

            if (issuematerial != null)
            {
                throw new ServerConflictException("Konto används för material i ärende " + issuematerial.issueid);
            }

            IssuePhoto issuephoto = context.IssuePhotos.FirstOrDefault(i => id == i.createdby);

            if (issuephoto != null)
            {
                throw new ServerConflictException("Konto används för fotografi i ärende " + issuephoto.issueid);
            }

            IssueTime issuetime = context.IssueTimes.FirstOrDefault(i => id == i.createdby);

            if (issuetime != null)
            {
                throw new ServerConflictException("Konto används för tid i ärende " + issuetime.issueid);
            }

            IssueTransition issuetransition = context.IssueTransitions.FirstOrDefault(i => id == i.createdby);

            if (issuetransition != null)
            {
                throw new ServerConflictException("Konto används för historik i ärende " + issuetransition.issueid);
            }

            // Do deletion
            Account dbentity = GetDBEntity(context, id);

            context.Accounts.Remove(dbentity);
            context.Entry(dbentity).State = System.Data.Entity.EntityState.Deleted;
        }
 public XElement Serialize()
 {
     return(new XElement(UblNames.Cac + nameof(AdditionalDocumentReference),
                         ID.Serialize(nameof(ID)),
                         UUID.Serialize(nameof(UUID)),
                         IssueDate.Serialize(nameof(IssueDate)),
                         IssueTime.Serialize(nameof(IssueTime)),
                         DocumentTypeCode.Serialize(nameof(DocumentTypeCode)),
                         DocumentType.Serialize(nameof(DocumentType)),
                         Attachment?.Serialize()));
 }
Example #5
0
        public static void TryDelete(Account requester, DataContext context, int id)
        {
            if (!requester.IsAtLeastManagement())
            {
                throw new ServerAuthorizeException("Du har inte behörighet att radera tidtyp");
            }
            // Issues -- delete NOT OK
            IssueTime issuetime = context.IssueTimes.FirstOrDefault(i => id == i.timetypeid);

            if (issuetime != null)
            {
                throw new ServerConflictException("Tidtyp används i ärende " + issuetime.issueid);
            }
            // Do deletion
            TimeType dbentity = GetDBEntity(context, id);

            context.TimeTypes.Remove(dbentity);
            context.Entry(dbentity).State = System.Data.Entity.EntityState.Deleted;
        }
 public XElement Serialize()
 {
     return(new XElement(UblNames.Cac + nameof(DocumentReference),
                         ID.Serialize(nameof(ID)),
                         CopyIndicator.Serialize(nameof(CopyIndicator)),
                         UUID.Serialize(nameof(UUID)),
                         IssueDate.Serialize(nameof(IssueDate)),
                         IssueTime.Serialize(nameof(IssueTime)),
                         DocumentTypeCode.Serialize(nameof(DocumentTypeCode)),
                         DocumentType.Serialize(nameof(DocumentType)),
                         XPath.Serialize(nameof(XPath)),
                         LanguageID.Serialize(nameof(LanguageID)),
                         LocaleCode.Serialize(nameof(LocaleCode)),
                         VersionID.Serialize(nameof(VersionID)),
                         DocumentStatusCode.Serialize(nameof(DocumentStatusCode)),
                         DocumentDescription.Serialize(nameof(DocumentDescription)),
                         Attachment?.Serialize(),
                         ValidityPeriod?.Serialize(nameof(ValidityPeriod)),
                         IssuerParty?.Serialize(nameof(IssuerParty))
                         ));
 }