# Classen zur Produktion von Metataden

# Classes for displaying, browsing and organizing the archive

import addFolder
import OSAS_add # methods for adding metadata and/or files

from Globals import InitializeClass,Persistent,package_home

from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from OFS.Traversable import Traversable
from OFS.Cache import Cacheable
from OFS.History import Historical, html_diff
from Shared.DC.Scripts.Script import Script, BindingsUI
from OFS.PropertyManager import PropertyManager
from ExtensionClass import Base
from Acquisition import Implicit
import string
import os
from AccessControl import ClassSecurityInfo


class OSAS_MetadataMapping(SimpleItem):
    """Einfaches Mapping Object"""

    meta_type="OSAS_MetadataMapping"

    def readFieldsFromParent(self):
        """read all elements from root"""
        #print self.getId()
        return self.aq_parent.fieldList
    
    def __init__(self,id,title,arglist,fieldList):
        """init"""
        self.id=id
        self.title=title
        self.fields=[]
        
        for fieldName in fieldList:
            setattr(self,"md_"+fieldName,arglist[fieldName])
            self.fields.append(arglist[fieldName])
            
    manage_options = SimpleItem.manage_options+(
        {'label':'Main Config','action':'change_OSAS_MappingForm'},
        )


    def showSetXML(self,RESPONSE=None):
        """prints out the mapping as XML"""
        ret="""<set name="%s">"""%self.title
        for fieldName in self.readFieldsFromParent():
            entry=getattr(self,"md_"+fieldName)
            if entry[2]=="": # no explanation of this field
                ret+="""<entry genericName="%s" tag="%s" label="%s"/>"""%(fieldName,entry[0],entry[1])
            else:
                ret+="""<entry genericName="%s" tag="%s" label="%s">%s</entry>"""%(fieldName,entry[0],entry[1],entry[2])
        ret+="</set>"

        if not RESPONSE:
            return ret
        else:
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
            return ret

    def getValue(self,fieldName):
        """get md value"""

        try:
            return getattr(self,"md_"+fieldName)
        except:
            return (None,None,None)

    def isEmptyValue(self,fieldName):
        """empty"""
        try:
            field=getattr(self,"md_"+fieldName)
            if field[1]=='':
                return 0
            else:
                return 1
        except:
            return 0
        
    def generateMappingHash(self):
        """erzeugen des Hash"""
        hash={}
        for field in self.fieldList:
            hash[field]=getattr(self,"md_"+field,'')
        return hash

       
    
    def change_OSAS_MappingForm(self):
        """change"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeOSAS_MetadataMapping.zpt')).__of__(self)
        return pt()
    
    def change_OSAS_Mapping(self,titleOfObject,RESPONSE=None):
        """change"""

        self.title=titleOfObject
        arglist=self.REQUEST.form
        self.fields=[]
        
        
        for fieldName in self.readFieldsFromParent():

            setattr(self,"md_"+fieldName,(arglist[fieldName],arglist['label_'+fieldName],arglist['explanation_'+fieldName]))
            self.fields.append(arglist[fieldName])
            
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    

def manage_addOSAS_MetadataMappingForm(self):
    """interface for adding the OSAS_root"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddOSAS_MetadataMapping.zpt')).__of__(self)
    return pt()

def manage_addOSAS_MetadataMapping(self,idOfObject,titleOfObject,RESPONSE=None):
    """add the OSAS_root"""
    
    argList={}
    for arg in self.fieldList:
        if not (arg in ['idOfObject','titleOfObject']):
            argList[arg]=(self.REQUEST.form[arg],self.REQUEST.form['label_'+arg],self.REQUEST.form['explanation_'+arg])
            
    newObj=OSAS_MetadataMapping(idOfObject,titleOfObject,argList,self.fieldList)
    self._setObject(idOfObject,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

   


class OSAS_add_Metadata(Folder):
    """Foldertype enthält methoden zur Halbautomatischen Erstellung von Metadatenfiles"""
    security=ClassSecurityInfo()
    
    def __init__(self,id,linklabel,description,fields):
        """initialize a new instance"""
        self.id = id
        self.linklabel =linklabel #label fuer link auf add page
        self.description=description #description of the method for link page
        self.fieldList=fields.split(",")[0:]
        
    meta_type='OSAS_add_Metadata'

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'add_Metadata_config'},
        )

    def showGenericXML(self,RESPONSE=None):
        """show generic fields as XML"""
        ret="""<set name="%s">"""%"generic"
        for field in self.fieldList:
            ret+="""<entry genericName="%s"/>"""%field

        ret+="</set>"
        
        if not RESPONSE:
            return ret
        else:
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
            return ret
    def showOverviewXML(self,RESPONSE):
        """gives an overview over the Metadata stored in this folder"""
        ret="""<metadata name="%s">"""%self.getId()
        ret+=self.showGenericXML()
        for entry in self.ZopeFind(self,obj_metatypes=['OSAS_MetadataMapping']):
            ret+=entry[1].showSetXML()

        ret+="</metadata>"

        if not RESPONSE:
            return ret
        else:
            self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
            return ret
        
    def generateMappingList(self):
        """Erzeuge Mapping"""
        mapping={}
        for dict in self.__dict__:
            #print dict
            obj=getattr(self,dict)
            if hasattr(obj,'meta_type'):
                if obj.meta_type=="OSAS_MetadataMapping":
                    mapping[obj.getId()]=obj.generateMappingHash()
        return mapping
    
    def generateMappingForType(self,type,clean="yes"):
        """erzeuge spezifisches Mapping"""
        hash=self.generateMappingList()
        if hash.has_key(type):
            if clean=="yes":
                temp={}
                for x in hash[type].keys():
                    if not hash[type][x]=="":
                        temp[x]=hash[type][x]
                return temp
            else:
                return hash[type]
        
        else:
            return {}

    def getFieldList(self):
        """erzeuge string aus fields"""
        try:
            return string.join(self.fieldList,",")
        except:
            return ""
        
    def getFields(self):
        """ausgabe der Felder"""
        return self.fieldList

    def getTypeTitle(self,id):
        """Title von ID"""
        try:
            obj=getattr(self,id)
            return obj.title
        except:
            return id
        
    def getStoredTypes(self):
        """Gebe gespeicherte typen zurück"""
        
        types=[]
        for dict in self.__dict__:
            
            obj=getattr(self,dict)
            if hasattr(obj,'meta_type'):
                if obj.meta_type=="OSAS_MetadataMapping":
                    #print obj
                    if obj.title=="":
                        title=obj.id
                    else:
                        title=obj.title
                    types.append((obj.id,title))
        return types
    
    security.declarePublic('add_Metadata_config')
    def add_Metadata_config(self):
        """Main configuration"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeOSAS_addMetadata.zpt')).__of__(self)
        return pt()
    
    security.declarePublic('change_OSAS_addMetadata')
    def change_OSAS_addMetadata(self,linklabel,description,fields,RESPONSE=None):
        """Change Metadata"""
        self.linklabel=linklabel
        self.description=description
        self.fieldList=fields.split(",")[0:]
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    security.declarePublic('index_html')
    def index_html(self):
        """standard aufruf"""
        return OSAS_add.add(self,no_upload=0)


    security.declarePublic('add2')
    def add2(self):
        """ anlegen naechster schritt"""
        return OSAS_add.add2(self)

    def add3(self):
        """Foldername"""
        return OSAS_add.add3(self)

    def add6(self):
        """write new index.meta file"""
        return OSAS_add.add6(self)

        
  
    
def manage_AddOSAS_add_MetadataForm(self):
    """interface for adding the OSAS_add_Metadata"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddOSAS_metadata.zpt')).__of__(self)
    return pt()

def manage_AddOSAS_add_Metadata(self,id,linklabel,description,fields,RESPONSE=None):
    """add the OSAS_root"""
    newObj=OSAS_add_Metadata(id,linklabel,description,fields)
    self.Destination()._setObject(id,newObj)
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

            
InitializeClass(OSAS_add_Metadata)